ecode-cutting 0.2.3__py3-none-any.whl

ecode_cutting/rectangular.py

@@ -0,0 +1,357 @@
+"""整数坐标的断头排料：每个可用区域始终是一棵二叉切割树的叶子。
+
+采用有界多策略启发式，不承诺 NP 困难问题的全局最优。内部切线表示锯缝
+起始边，公开 Cut 输出刀具中心线，树的前序遍历即实际加工顺序。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from random import Random
+from typing import Sequence
+
+from ._common import Runtime, matches, quantize
+from .models import Cut, Layout, Options, Part, Placement, Remnant, Result, Stock, Unplaced, ValidationError
+
+
+@dataclass(slots=True)
+class _Region:
+    x: int
+    y: int
+    w: int
+    h: int
+    direction: str = ""
+    level: int = 0
+    split: str = ""
+    position: int = 0
+    first: _Region | None = None
+    second: _Region | None = None
+    part: tuple[int, int, int, int, bool] | None = None
+
+
+def _stages(region: _Region, directions: list[str]) -> list[int]:
+    direction, level = region.direction, region.level
+    levels = []
+    for current in directions:
+        level += current != direction
+        direction = current
+        levels.append(level)
+    return levels
+
+
+def _splits(region: _Region, w: int, h: int, first: str, saw: int,
+            options: Options) -> tuple[list[str], list[int]] | None:
+    if w > region.w or h > region.h:
+        return None
+    # 不足一道锯缝的尾边不能假装成为零件，也不能吞进零件尺寸。
+    dw, dh = region.w - w, region.h - h
+    if (dw and dw < saw) or (dh and dh < saw):
+        return None
+    directions = [d for d in (first, "h" if first == "v" else "v")
+                  if (dw if d == "v" else dh)]
+    # 指定方向约束第一道实际分割；已经恰好等于原料的零件无需切割。
+    if not region.direction and directions and options.cut_direction != "auto":
+        required = "v" if options.cut_direction == "vertical" else "h"
+        if directions[0] != required:
+            return None
+    levels = _stages(region, directions)
+    if levels and max(levels) > options.max_cut_level:
+        return None
+    return directions, levels
+
+
+def _insert(region: _Region, index: int, instance: int, w: int, h: int,
+            rotated: bool, directions: list[str], levels: list[int], saw: int) -> list[_Region]:
+    free = []
+    current = region
+    for direction, level in zip(directions, levels):
+        current.split = direction
+        current.level = level
+        current.position = current.x + w if direction == "v" else current.y + h
+        if direction == "v":
+            current.first = _Region(current.x, current.y, w, current.h, direction, level)
+            current.second = _Region(current.x + w + saw, current.y,
+                                     current.w - w - saw, current.h, direction, level)
+        else:
+            current.first = _Region(current.x, current.y, current.w, h, direction, level)
+            current.second = _Region(current.x, current.y + h + saw,
+                                     current.w, current.h - h - saw, direction, level)
+        if current.second.w > 0 and current.second.h > 0:
+            free.append(current.second)
+        current = current.first
+    current.part = (index, instance, w, h, rotated)
+    return free
+
+
+def _pack(stock: Stock, dimensions: tuple[int, int], counts: list[int], parts: Sequence[Part],
+          sizes: list[tuple[int, int]], order: list[int], options: Options, runtime: Runtime,
+          attempt: int, placed_before: int) -> tuple[_Region, list[int]]:
+    left, top, right, bottom = (quantize(getattr(options, "trim_" + edge), options.max_decimal_point)
+                                for edge in ("left", "top", "right", "bottom"))
+    root = _Region(left, top, dimensions[0] - left - right, dimensions[1] - top - bottom)
+    used = [0] * len(parts)
+    if root.w <= 0 or root.h <= 0:
+        return root, used
+    free = [root]
+    saw = quantize(options.saw_width, options.max_decimal_point)
+    minimum = quantize(options.waste_size_min, options.max_decimal_point)
+    placed = 0
+    history = []
+    last_valid = 0
+    used_right, used_bottom = root.x, root.y
+
+    def valid_remnants():
+        for r in free:
+            rw, rh = r.w, r.h
+            if options.roll_mode:
+                if options.cut_direction == "vertical":
+                    rw = min(r.x + rw, used_right) - r.x
+                else:
+                    rh = min(r.y + rh, used_bottom) - r.y
+            if rw > 0 and rh > 0 and ((rw < minimum and rw != root.w) or
+                                      (rh < minimum and rh != root.h)):
+                return False
+        return True
+    while free:
+        if runtime.stopped(placed_before + placed, attempt):
+            break
+        selected = None
+        for index in order:
+            part = parts[index]
+            if counts[index] <= used[index] or not matches(stock.material, part.material):
+                continue
+            w0, h0 = sizes[index]
+            orientations = [(w0, h0, False)]
+            if part.rotatable and w0 != h0:
+                orientations.append((h0, w0, True))
+            best = None
+            for free_index, region in enumerate(free):
+                for w, h, rotated in orientations:
+                    for first in ("v", "h"):
+                        valid = _splits(region, w, h, first, saw, options)
+                        if valid is None:
+                            continue
+                        directions, levels = valid
+                        # 优先贴合短边，避免把可重复利用的整条原料切成碎片。
+                        dw, dh = region.w - w, region.h - h
+                        repeat_capacity = ((region.w + saw) // (w + saw)) * ((region.h + saw) // (h + saw))
+                        score = (region.w * region.h - w * h, -repeat_capacity, min(dw, dh), max(dw, dh), len(directions), rotated,
+                                 0 if first == ("v" if attempt % 2 == 0 else "h") else 1)
+                        if options.minimize_sheet_rotation:
+                            score = (max(levels, default=region.level),) + score
+                        candidate = (score, free_index, w, h, rotated, directions, levels)
+                        if best is None or score < best[0]:
+                            best = candidate
+            if best is not None:
+                selected = (index, best)
+                break
+        if selected is None:
+            break
+        index, (_, free_index, w, h, rotated, directions, levels) = selected
+        region = free.pop(free_index)
+        if minimum:
+            history.append((region, index, region.level))
+        free.extend(_insert(region, index, used[index], w, h, rotated, directions, levels, saw))
+        used[index] += 1
+        placed += 1
+        used_right, used_bottom = max(used_right, region.x + w), max(used_bottom, region.y + h)
+        if minimum and valid_remnants():
+            last_valid = len(history)
+    # 最小余料约束作用于最终余料，允许中间的小区域被后续零件恰好填满。
+    # 回退最后一段尚未形成合法余料的放置，保留此前已取得的有效部分布局。
+    for region, index, old_level in reversed(history[last_valid:]):
+        region.split, region.position, region.level = "", 0, old_level
+        region.first = region.second = None
+        region.part = None
+        used[index] -= 1
+    return root, used
+
+
+def _layout(stock_index: int, instance: int, stock: Stock, root: _Region, offsets: list[int],
+            parts: Sequence[Part], options: Options, scale: int) -> Layout:
+    nodes = [root]
+    occupied = []
+    while nodes:
+        node = nodes.pop()
+        if node.part is not None:
+            occupied.append(node)
+        if node.first is not None:
+            nodes.extend((node.second, node.first))
+    left, top, right, bottom = (quantize(getattr(options, "trim_" + edge), options.max_decimal_point)
+                                for edge in ("left", "top", "right", "bottom"))
+    width, height = quantize(stock.width, options.max_decimal_point), quantize(stock.height, options.max_decimal_point)
+    original_width, original_height = width, height
+    saw = quantize(options.saw_width, options.max_decimal_point)
+    half_saw = saw / 2
+    if options.roll_mode:
+        if options.cut_direction == "vertical":
+            width = max(n.x + n.part[2] for n in occupied) + right
+            if width + saw > original_width:
+                width = original_width
+        else:
+            height = max(n.y + n.part[3] for n in occupied) + bottom
+            if height + saw > original_height:
+                height = original_height
+    usable_right, usable_bottom = width - right, height - bottom
+    placements, remnants, cuts = [], [], []
+    visited, cut_nodes, part_nodes = [], [], {}
+    nodes = [root]
+    while nodes:
+        node = nodes.pop()
+        w, h = min(node.x + node.w, usable_right) - node.x, min(node.y + node.h, usable_bottom) - node.y
+        if w <= 0 or h <= 0:
+            continue
+        visited.append(node)
+        if node.part is not None:
+            index, item, pw, ph, rotated = node.part
+            part = parts[index]
+            part_nodes[id(node)] = (len(placements),)
+            placements.append(Placement(index, offsets[index] + item, pw / scale, ph / scale,
+                                        node.x / scale, node.y / scale, part.id, part.material, rotated))
+        elif node.split:
+            # 卷材末端缩短以后，与新边缘重合的分割已经成为原料边，不再输出空刀。
+            if node.split == "v" and node.position < usable_right:
+                cuts.append(Cut((node.position + half_saw) / scale, node.y / scale, (node.position + half_saw) / scale,
+                                (node.y + h) / scale, node.level, 90.0))
+                cut_nodes.append(node)
+            elif node.split == "h" and node.position < usable_bottom:
+                cuts.append(Cut(node.x / scale, (node.position + half_saw) / scale, (node.x + w) / scale,
+                                (node.position + half_saw) / scale, node.level, 0.0))
+                cut_nodes.append(node)
+            nodes.extend((node.second, node.first))
+        else:
+            remnants.append(Remnant(w / scale, h / scale, node.x / scale, node.y / scale, stock.material))
+    for node in reversed(visited):
+        if node.first is not None:
+            part_nodes[id(node)] = part_nodes.get(id(node.first), ()) + part_nodes.get(id(node.second), ())
+    cuts = [replace(cut, part_indices=part_nodes.get(id(node), ())) for cut, node in zip(cuts, cut_nodes)]
+    # 卷材先切断实际用长。刀具中心落在保留板外半道锯缝处，锯缝由原卷尾段承担。
+    trim, roll_remnants = [], []
+    all_parts = tuple(range(len(placements)))
+    if width < original_width:
+        trim.append(Cut((width + half_saw) / scale, 0, (width + half_saw) / scale,
+                        height / scale, part_indices=all_parts))
+        if width + saw < original_width:
+            roll_remnants.append(Remnant((original_width - width - saw) / scale,
+                                         original_height / scale, (width + saw) / scale,
+                                         0, stock.material))
+    if height < original_height:
+        trim.append(Cut(0, (height + half_saw) / scale, width / scale,
+                        (height + half_saw) / scale, angle=0, part_indices=all_parts))
+        if height + saw < original_height:
+            roll_remnants.append(Remnant(original_width / scale,
+                                         (original_height - height - saw) / scale,
+                                         0, (height + saw) / scale, stock.material))
+    # 修边沿丢弃的一侧吃刀，中心线不会侵入可用板；首向跟随主刀方向。
+    vertical_first = root.split == "v" or (not root.split and options.cut_direction != "horizontal")
+    for vertical in (vertical_first, not vertical_first):
+        if vertical:
+            y1, y2 = (0, height) if vertical_first else (top, height - bottom)
+            for position, margin in ((left - half_saw, left), (width - right + half_saw, right)):
+                if margin:
+                    trim.append(Cut(position / scale, y1 / scale, position / scale, y2 / scale,
+                                    part_indices=all_parts))
+        else:
+            x1, x2 = (left, width - right) if vertical_first else (0, width)
+            for position, margin in ((top - half_saw, top), (height - bottom + half_saw, bottom)):
+                if margin:
+                    trim.append(Cut(x1 / scale, position / scale, x2 / scale, position / scale,
+                                    angle=0, part_indices=all_parts))
+    return Layout(stock_index, instance, width / scale, height / scale, stock.id, stock.material,
+                  stock.waste, tuple(placements), tuple(remnants), tuple(cuts), tuple(trim),
+                  roll_remnants=tuple(roll_remnants))
+
+
+def _signature(layout: Layout) -> tuple:
+    return (layout.input_index, layout.width, layout.height,
+            tuple(sorted((p.input_index, p.x, p.y, p.width, p.height) for p in layout.parts)))
+
+
+def solve_rectangular(stocks: Sequence[Stock], parts: Sequence[Part], options: Options, runtime: Runtime) -> Result:
+    """计算矩形断头排料，库存为零表示不限量；所有尝试共享同一个时间预算。"""
+    scale = 10 ** options.max_decimal_point
+    sizes = [(quantize(p.width, options.max_decimal_point), quantize(p.height, options.max_decimal_point)) for p in parts]
+    stock_sizes = [(quantize(s.width, options.max_decimal_point), quantize(s.height, options.max_decimal_point)) for s in stocks]
+    requested = sum(p.count for p in parts)
+    if runtime.stopped():
+        return Result(unplaced=tuple(Unplaced(i, p.count, p.id) for i, p in enumerate(parts) if p.count),
+                      elapsed=runtime.elapsed, cancelled=runtime.cancelled, timed_out=runtime.timed_out)
+    # CompleteMode 的前置语义与旧实现一致；库存数量不足仍以 unplaced 返回。
+    if options.complete_mode:
+        for index, part in enumerate(parts):
+            if runtime.stopped():
+                break
+            if not part.count:
+                continue
+            possible = False
+            for stock, (sw, sh) in zip(stocks, stock_sizes):
+                region = _Region(0, 0, sw - quantize(options.trim_left, options.max_decimal_point)
+                                 - quantize(options.trim_right, options.max_decimal_point),
+                                 sh - quantize(options.trim_top, options.max_decimal_point)
+                                 - quantize(options.trim_bottom, options.max_decimal_point))
+                if not matches(stock.material, part.material):
+                    continue
+                w, h = sizes[index]
+                for pw, ph in ((w, h), (h, w)) if part.rotatable else ((w, h),):
+                    if any(_splits(region, pw, ph, first, quantize(options.saw_width, options.max_decimal_point), options) is not None
+                           for first in ("v", "h")):
+                        possible = True
+                        break
+                if possible:
+                    break
+            if not possible:
+                raise ValidationError(f"零件 {index} 无法在材料、修边、锯缝及切割层级约束下放入任何原料")
+    best_layouts = []
+    best_unplaced = [p.count for p in parts]
+    best_score = None
+    attempts = 0
+    random = Random(options.seed)
+    for attempt in range(options.max_attempts):
+        if runtime.stopped(requested - sum(best_unplaced), attempt):
+            break
+        attempts += 1
+        remaining = [p.count for p in parts]
+        consumed = [0] * len(stocks)
+        offsets = [0] * len(parts)
+        layouts = []
+        order = sorted(range(len(parts)), key=lambda i: (sizes[i][0] * sizes[i][1], max(sizes[i])), reverse=True)
+        if attempt == 1:
+            order.sort(key=lambda i: max(sizes[i]), reverse=True)
+        elif attempt == 2:
+            order.sort(key=lambda i: min(sizes[i]), reverse=True)
+        elif attempt > 2:
+            random.shuffle(order)
+        while any(remaining) and not runtime.stopped(requested - sum(remaining), attempt):
+            candidates = []
+            for stock_index, stock in enumerate(stocks):
+                if stock.count and consumed[stock_index] >= stock.count:
+                    continue
+                root, used = _pack(stock, stock_sizes[stock_index], remaining, parts, sizes, order,
+                                   options, runtime, attempt, requested - sum(remaining))
+                if not any(used):
+                    continue
+                layout = _layout(stock_index, consumed[stock_index], stock, root, offsets, parts, options, scale)
+                used_area = sum(p.width * p.height for p in layout.parts)
+                repeated = options.use_layout_minimization and any(_signature(old) == _signature(layout) for old in layouts)
+                stock_area = layout.width * layout.height
+                size_score = -stock_area if options.use_large_stock_first else stock_area / used_area
+                candidates.append(((not stock.waste, -int(repeated), size_score, -used_area, stock_index), layout, used))
+                if runtime.stopped(requested - sum(remaining), attempt):
+                    break
+            if not candidates:
+                break
+            _, layout, used = min(candidates, key=lambda item: item[0])
+            layouts.append(layout)
+            consumed[layout.input_index] += 1
+            remaining = [n - u for n, u in zip(remaining, used)]
+            offsets = [n + u for n, u in zip(offsets, used)]
+        area = sum(layout.width * layout.height for layout in layouts)
+        patterns = len({_signature(layout) for layout in layouts})
+        score = (sum(remaining), patterns if options.use_layout_minimization else 0, area, len(layouts),
+                 sum(max((c.level for c in layout.cuts), default=0) for layout in layouts))
+        if best_score is None or score < best_score:
+            best_score, best_layouts, best_unplaced = score, layouts, remaining
+        if runtime.stopped(requested - sum(remaining), attempt):
+            break
+    return Result(tuple(best_layouts), tuple(Unplaced(i, n, parts[i].id) for i, n in enumerate(best_unplaced) if n),
+                  runtime.elapsed, False, runtime.cancelled, runtime.timed_out, attempts)

ecode_cutting/serialization.py

@@ -0,0 +1,234 @@
+"""可移植的版本化任务和结果格式；不接受非有限数值及 XML 实体声明。"""
+
+from dataclasses import asdict
+import json
+import math
+import re
+import xml.etree.ElementTree as ET
+
+from .models import (Cut, Layout, LayoutGroup, Material, Options, Part, Placement, Remnant,
+                     Result, Stock, StockComponent, Unplaced, ValidationError,
+                     UnsupportedFeatureError)
+
+
+def _check(value):
+    if isinstance(value, float) and not math.isfinite(value):
+        raise ValidationError("序列化数据必须为有限数值")
+    if isinstance(value, str) and re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f\ud800-\udfff\ufffe\uffff]", value):
+        raise ValidationError("字符串包含非法 XML 或 Unicode 字符")
+    if isinstance(value, dict):
+        for key, item in value.items():
+            _check(key)
+            _check(item)
+    elif isinstance(value, (list, tuple)):
+        for item in value:
+            _check(item)
+
+
+def _dump(data):
+    _check(data)
+    return json.dumps(data, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
+
+
+def _load(text):
+    try:
+        data = json.loads(text, parse_constant=lambda _: (_ for _ in ()).throw(ValueError("非有限数值")))
+        _check(data)
+        if not isinstance(data, dict) or data.get("version") != 1:
+            raise ValidationError("不支持的文档版本")
+        return data
+    except (ValueError, TypeError, UnicodeError) as exc:
+        raise ValidationError(f"JSON 数据无效: {exc}") from exc
+
+
+def job_to_json(stocks, parts, options=None, materials=()):
+    """输出独立 Python 包的版本化任务格式。"""
+    return _dump(dict(version=1, kind="job", stocks=[asdict(s) for s in stocks],
+                      parts=[asdict(p) for p in parts], options=asdict(options or Options()),
+                      materials=[asdict(m) for m in materials]))
+
+
+def job_from_json(text):
+    """返回 (stocks, parts, options, materials)，均为公开模型实例。"""
+    data = _load(text)
+    try:
+        if data.get("kind") != "job":
+            raise ValidationError("文档不是任务")
+        return ([Stock(**s) for s in data["stocks"]], [Part(**p) for p in data["parts"]],
+                Options(**data["options"]), [Material(**m) for m in data["materials"]])
+    except (KeyError, TypeError) as exc:
+        raise ValidationError(f"任务结构无效: {exc}") from exc
+
+
+def result_to_json(result):
+    return _dump(dict(version=1, kind="result", result=asdict(result)))
+
+
+def result_from_json(text):
+    data = _load(text)
+    try:
+        if data.get("kind") != "result":
+            raise ValidationError("文档不是结果")
+        value = data["result"]
+        layouts = []
+        for row in value.pop("layouts"):
+            parts = []
+            for p in row.pop("parts"):
+                p["polygon"] = tuple(tuple(pt) for pt in p.get("polygon", ()))
+                parts.append(Placement(**p))
+            row["parts"] = tuple(parts)
+            for name in ("remnants", "roll_remnants"):
+                row[name] = tuple(Remnant(**r) for r in row.get(name, ()))
+            for name in ("cuts", "trim_cuts"):
+                cuts = []
+                for c in row.get(name, ()):
+                    c["part_indices"] = tuple(c.get("part_indices", ()))
+                    cuts.append(Cut(**c))
+                row[name] = tuple(cuts)
+            row["components"] = tuple(StockComponent(**c) for c in row.get("components", ()))
+            layouts.append(Layout(**row))
+        value["layouts"] = tuple(layouts)
+        value["unplaced"] = tuple(Unplaced(**u) for u in value.get("unplaced", ()))
+        value["layout_groups"] = tuple(LayoutGroup(**g) for g in value.get("layout_groups", ()))
+        return Result(**value)
+    except (KeyError, TypeError, AttributeError) as exc:
+        raise ValidationError(f"结果结构无效: {exc}") from exc
+
+
+def _to_xml(text):
+    # 每个字段保存带类型 JSON 值，保留空值、布尔值、浮点数和任意中文 ID。
+    data = _load(text)
+    root = ET.Element("ECodeCutting", version="1", kind=data["kind"])
+    for key, value in data.items():
+        if key not in ("version", "kind"):
+            ET.SubElement(root, key, encoding="json").text = _dump(value)
+    return ET.tostring(root, encoding="unicode", xml_declaration=True)
+
+
+def _from_xml(text):
+    if isinstance(text, bytes):
+        try:
+            text = text.decode("utf-8-sig")
+        except UnicodeError as exc:
+            raise ValidationError("XML 必须为 UTF-8") from exc
+    if not isinstance(text, str) or re.search(r"<!\s*(DOCTYPE|ENTITY)", text, re.I):
+        raise ValidationError("不允许 XML DTD 或实体声明")
+    try:
+        root = ET.fromstring(text)
+        if root.tag != "ECodeCutting" or root.get("version") != "1":
+            raise ValidationError("不支持的 XML 文档")
+        data = dict(version=1, kind=root.get("kind"))
+        for child in root:
+            if child.tag in data or child.get("encoding") != "json":
+                raise ValidationError("重复或不支持的 XML 字段")
+            data[child.tag] = json.loads(child.text or "null")
+        return _dump(data)
+    except (ET.ParseError, ValueError, TypeError) as exc:
+        raise ValidationError(f"XML 数据无效: {exc}") from exc
+
+
+def job_to_xml(stocks, parts, options=None, materials=()):
+    return _to_xml(job_to_json(stocks, parts, options, materials))
+
+
+def job_from_xml(text):
+    # 原 CutGLib 的 Stocks/Parts/Part_N 属性形式也是可读取的任务输入。
+    if isinstance(text, bytes):
+        try:
+            text = text.decode("utf-8-sig")
+        except UnicodeError as exc:
+            raise ValidationError("XML 必须为 UTF-8") from exc
+    if not isinstance(text, str) or re.search(r"<!\s*(DOCTYPE|ENTITY)",text,re.I):
+        raise ValidationError("不允许 XML DTD 或实体声明")
+    try:
+        root=ET.fromstring(text)
+    except ET.ParseError as exc:
+        raise ValidationError(f"XML 数据无效: {exc}") from exc
+    if root.tag=="ECodeCutting":
+        return job_from_json(_from_xml(text))
+    return _legacy_job(root)
+
+
+def _legacy_job(root):
+    from fractions import Fraction
+    def dimension(value):
+        if value in (None,"","NULL"): return 0.0
+        try:
+            # DimensionValue 的英尺英寸存储为总英寸分数，例如 305/2"；
+            # Units 仅控制显示，不额外乘以毫米或厘米换算系数。
+            value=value.translate(str.maketrans({c:"'" for c in "‘`‛‚’"}|{c:'"' for c in "“”„‟"})).strip()
+            feet=Fraction(0)
+            if "'" in value:
+                left,value=value.split("'",1)
+                feet=Fraction(left.strip())*12
+            if '"' in value:
+                if not value.endswith('"') or value.count('"')!=1:
+                    raise ValueError("英寸标记位置错误")
+                value=value[:-1].strip()
+            pieces=value.split()
+            result=float(feet+sum((Fraction(p) for p in pieces),Fraction(0)))
+            _check(result)
+            return result
+        except (ValueError,ZeroDivisionError) as exc:
+            raise ValidationError("旧 XML 尺寸无效") from exc
+    def boolean(value):
+        if value.lower() in ("true","1","yes"): return True
+        if value.lower() in ("false","0","no"): return False
+        raise ValidationError("旧 XML 布尔值无效")
+    if root.find("Parts") is None:
+        raise ValidationError("未识别到 CutGLib XML Parts 集合")
+    holes=root.find("Holes")
+    if holes is not None and (len(holes) or int(holes.get("Count","0"))):
+        raise UnsupportedFeatureError("当前公开模型未提供旧 XML 排除区域")
+    options=Options()
+    dimension_names={"SawWidth":"saw_width","TrimLeft":"trim_left","TrimTop":"trim_top",
+                     "TrimRight":"trim_right","TrimBottom":"trim_bottom","WasteSizeMin":"waste_size_min",
+                     "CrossSection":"cross_section","LinearMaxSizePerStockThreshold":"linear_max_size_per_stock_threshold"}
+    integer_names={"MaxCutLevel":"max_cut_level","MaxPatternSize":"max_layout_size",
+                   "LinearMaxSizePerStock":"linear_max_size_per_stock","MaxSizePerStock":"max_size_per_stock"}
+    boolean_names={"CompleteMode":"complete_mode","LinearAllowRotate":"linear_allow_rotate",
+                   "LinearExactAngle":"linear_exact_angle","LinearAllowFlipping":"linear_allow_flipping",
+                   "RollMode":"roll_mode","AllowCombineStockPriority":"allow_combine_stock_regular_and_waste"}
+    try:
+        for old,new in dimension_names.items():
+            if old in root.attrib: setattr(options,new,dimension(root.get(old)))
+        for old,new in integer_names.items():
+            if old in root.attrib: setattr(options,new,int(root.get(old)))
+        for old,new in boolean_names.items():
+            if old in root.attrib: setattr(options,new,boolean(root.get(old)))
+        options.use_layout_minimization=dimension(root.get("PatternScale"))>0
+        options.cut_direction={1:"horizontal",2:"vertical",3:"auto"}[int(root.get("Orientation","3"))]
+        def records(tag,cls):
+            group=root.find(tag)
+            if group is None: return []
+            if int(group.get("Count",str(len(group))))!=len(group):
+                raise ValidationError("旧 XML 集合 Count 与实际数量不一致")
+            result=[]
+            for element in group:
+                if not re.fullmatch(r"Part_\d+",element.tag):
+                    raise ValidationError("旧 XML 集合记录名无效")
+                if not boolean(element.get("Active","true")): continue
+                data=dict(width=dimension(element.get("Width")),height=dimension(element.get("Height")),
+                          count=int(element.get("Count","1")),id=element.get("ID",""),material=int(element.get("Material","-1")))
+                if cls is Part:
+                    data.update(rotatable=boolean(element.get("Rotatable","true")),
+                                angle_start=dimension(element.get("AngleStart")),angle_end=dimension(element.get("AngleEnd")))
+                else: data["waste"]=int(element.get("Priority","0"))!=0
+                result.append(cls(**data))
+            return result
+        stocks=records("Stocks",Stock)
+        if not stocks and root.find("Stock") is not None:
+            default=root.find("Stock")
+            stocks=[Stock(dimension(default.get("Width")),dimension(default.get("Height")),0,default.get("ID",""),material=int(default.get("Material","-1")))]
+        parts=records("Parts",Part)
+        return stocks,parts,options,[]
+    except (TypeError,ValueError,KeyError) as exc:
+        raise ValidationError(f"旧 XML 任务无效: {exc}") from exc
+
+
+def result_to_xml(result):
+    return _to_xml(result_to_json(result))
+
+
+def result_from_xml(text):
+    return result_from_json(_from_xml(text))