ecode-cutting 0.2.3__py3-none-any.whl

ecode_cutting/compat.py

@@ -0,0 +1,659 @@
+"""手册兼容入口：保留 bool/out 和错误字符串，计算仍由纯 Python 内核完成。
+
+原生 CutEngine 返回结构化模型；需要按 C# 手册迁移调用时使用 CutGLibEngine。
+Out 是 Python 对 ref/out 的显式表示，不加载 CLR，也不伪造旧产品许可证。
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, replace
+from math import isfinite, radians, tan
+
+from .engine import CutEngine, _OPTION_NAMES, _layout_key
+from .models import Layout, Material, Options, Part, Result, Stock, UnsupportedFeatureError, ValidationError
+
+
+@dataclass
+class Out:
+    value: object = None
+
+    def __getitem__(self, index):
+        if index != 0:
+            raise IndexError(index)
+        return self.value
+
+    def __setitem__(self, index, value):
+        if index != 0:
+            raise IndexError(index)
+        self.value = value
+
+
+class QueryResult(tuple):
+    """未提供 Out 时返回 (成功标志, 输出值...)；布尔判断使用成功标志。"""
+
+    def __new__(cls, success, values):
+        return super().__new__(cls, (bool(success), *values))
+
+    def __bool__(self):
+        return self[0]
+
+
+def _answer(outputs, success, values):
+    if outputs:
+        if len(outputs) != len(values) or any(not isinstance(out, Out) for out in outputs):
+            raise TypeError("out 参数必须逐一传入 Out()，数量需与所选重载相同")
+        for out, value in zip(outputs, values):
+            out.value = value
+        return bool(success)
+    return QueryResult(success, values)
+
+
+# 输入参数个数、每种输出重载的默认值。输出顺序与手册/实测签名一致。
+_QUERIES = {
+    "GetMaterial": (1, {3: ("", "", 0.0)}),
+    "GetLayoutInfo": (1, {2: (0, 0)}),
+    "GetStockInfo": (1, {3: (0.0, 0.0, False), 4: (0.0, 0.0, False, "")}),
+    "GetLinearStockInfo": (1, {2: (0.0, False), 3: (0.0, False, "")}),
+    "GetLinearCombineStockInfo": (2, {3: (0.0, False, "")}),
+    "GetResultPart": (1, {6: (-1, 0.0, 0.0, 0.0, 0.0, False), 7: (-1, 0.0, 0.0, 0.0, 0.0, False, "")}),
+    "GetResultLinearPart": (1, {3: (-1, 0.0, 0.0), 4: (-1, 0.0, 0.0, ""),
+        6: (-1, 0.0, 0.0, 0.0, 0.0, False), 7: (-1, 0.0, 0.0, 0.0, 0.0, False, False),
+        8: (-1, 0.0, 0.0, 0.0, 0.0, False, False, "")}),
+    "GetRemainingPart": (1, {5: (-1, 0.0, 0.0, 0.0, 0.0)}),
+    "GetRemainingLinearPart": (1, {3: (-1, 0.0, 0.0), 4: (-1, 0.0, 0.0, 0.0)}),
+    "GetCut": (1, {5: (0, 0.0, 0.0, 0.0, 0.0), 6: (0, 0.0, 0.0, 0.0, 0.0, 0)}),
+    "GetPartCut": (2, {5: (-1, 0.0, 0.0, 0.0, 0.0)}),
+    "GetStockCut": (2, {4: (0.0, 0.0, 0.0, 0.0), 5: (0.0, 0.0, 0.0, 0.0, 0)}),
+    "GetStockTrimCut": (2, {4: (0.0, 0.0, 0.0, 0.0), 5: (0.0, 0.0, 0.0, 0.0, 0)}),
+    "GetLinearCut": (1, {2: (0, 0.0), 3: (0, 0.0, 0.0)}),
+    "GetLinearStockCut": (2, {1: (0.0,), 2: (0.0, 0.0)}),
+}
+
+
+class CutGLibEngine(CutEngine):
+    """手册中的大小写名称采用兼容契约；snake_case 方法保留 Python 原生契约。"""
+
+    reference_version = "5.3.8"
+
+    def __init__(self, options=None, **settings):
+        super().__init__(options)
+        self._inventory_cache = None
+        for name, value in settings.items():
+            if name in _OPTION_NAMES:
+                setattr(self, name, value)
+            elif name in Options.__dataclass_fields__:
+                setattr(self.options, name, value)
+            else:
+                raise TypeError(f"未知计算参数：{name}")
+
+    def __setattr__(self, name, value):
+        if name == "MaxDecimalPoint":
+            if type(value) is not int:
+                raise TypeError("MaxDecimalPoint 必须是整数")
+            value = min(6, max(0, value))
+        super().__setattr__(name, value)
+
+    def _modify(self, action):
+        value = super()._modify(action)
+        self._inventory_cache = None
+        return value
+
+    @staticmethod
+    def _number(value):
+        if isinstance(value, (str, bytes, bool)):
+            raise TypeError("尺寸必须是数值")
+        value = float(value)
+        return value
+
+    def _append(self, record):
+        # 原 DLL 的 Add 阶段接受负尺寸；执行阶段再报告尺寸错误，原生入口仍严格校验。
+        if not isfinite(record.width) or not isfinite(record.height):
+            return False
+        if abs(record.width) <= 1e-12 or abs(record.height) <= 1e-12:
+            return False
+        if type(record.count) is not int or type(record.material) is not int:
+            raise TypeError("数量与材料索引必须是整数")
+        target = self._parts if isinstance(record, Part) else self._stocks
+        self._modify(lambda: target.append(record))
+        return True
+
+    def AddPart(self, width, height, count=1, rotatable=True, id="", material=-1):
+        if type(count) is bool:
+            count, rotatable = 1, count
+        return self._append(Part(self._number(width), self._number(height), max(0, count), rotatable, id, material))
+
+    def AddStock(self, width, height, count=1, id="", waste=False, material=-1):
+        return self._append(Stock(self._number(width), self._number(height), max(0, count), id, waste, material))
+
+    def AddLinearPart(self, length, count=1, *args):
+        if args and isinstance(args[0], str):
+            if len(args) > 2:
+                raise TypeError("AddLinearPart 参数过多")
+            id, material = args[0], args[1] if len(args) == 2 else -1
+            start = end = 0.0
+        elif args:
+            if not 2 <= len(args) <= 4:
+                raise TypeError("斜角重载需要起始角和结束角")
+            start, end = map(self._number, args[:2])
+            id, material = args[2] if len(args) > 2 else "", args[3] if len(args) > 3 else -1
+        else:
+            id, material, start, end = "", -1, 0.0, 0.0
+        return self._append(Part(self._number(length), 1.0, max(0, count), False, id, material, start, end))
+
+    def AddLinearStock(self, length, count=1, *args):
+        if len(args) == 1 and type(args[0]) is int:
+            id, waste, material = "", False, args[0]
+        elif len(args) <= 3:
+            id, waste, material = (args[0] if args else "", args[1] if len(args) > 1 else False,
+                                   args[2] if len(args) > 2 else -1)
+        else:
+            raise TypeError("AddLinearStock 参数过多")
+        return self._append(Stock(self._number(length), 1.0, max(0, count), id, waste, material))
+
+    def AddMaterial(self, id, description, thickness):
+        thickness = self._number(thickness)
+        if not isfinite(thickness):
+            raise ValidationError("材质厚度必须有限")
+        def add():
+            self._materials.append(Material(id, description, thickness))
+            return len(self._materials) - 1
+        return self._modify(add)
+
+    def Clear(self):
+        # 原 5.3.8 Clear 实测保留三个搜索开关和尺寸精度，其余恢复默认。
+        retained = {name: getattr(self.options, name) for name in
+                    ("linear_allow_flipping", "linear_sort_ascending", "use_large_stock_first", "max_decimal_point")}
+        self.clear(reset_options=True)
+        for name, value in retained.items():
+            setattr(self.options, name, value)
+
+    def _run_documented(self, linear, callback):
+        self._inventory_cache = None
+        if not self.part_count:
+            return "Number of parts must be more than zero"
+        if not self.stocks:
+            return "Length of stock 0 is negative (0). Please check trims and saw kerf values to be less then the stock length."
+        def progress(_):
+            stop = Out(False)
+            returned = callback(stop)
+            return bool(stop.value) or returned is True
+        try:
+            result = self.execute_linear(progress if callback else None) if linear else self.execute(progress if callback else None)
+        except ValidationError as exc:
+            if "无法" in str(exc) or "cannot" in str(exc):
+                # 公开错误字符串与原版一致；异常输入仍可通过原生接口获得详细中文错误。
+                for part in self.parts:
+                    return f"Part {part.id} cannot be placed because it exceeds the stock size"
+            return str(exc)
+        if result.cancelled:
+            return "Calculation stopped by the user"
+        if result.timed_out:
+            return "Calculation time limit reached"
+        return ""
+
+    def Execute(self, callback=None):
+        return self._run_documented(False, callback)
+
+    def ExecuteLinear(self, callback=None):
+        return self._run_documented(True, callback)
+
+    def _execute(self, linear, callback, *, solver=None):
+        self._inventory_cache = None
+        return super()._execute(linear, callback, solver=solver)
+
+    def _inventory(self):
+        """按原版材料/尺寸排序，批次保存未用库存，避免展开 20000 根无限原料。"""
+        if self._inventory_cache is not None:
+            return self._inventory_cache
+        if self._result is None:
+            return (), {}, 0
+        consumed = Counter()
+        active = {}
+        combined = []
+        for index, layout in enumerate(self.result.layouts):
+            components = layout.components
+            if len(components) > 1:
+                consumed.update(c.input_index for c in components)
+                ordered = sorted(components, key=lambda c: (c.width, c.input_index))
+                id = ";".join(self._component_id(c) for c in ordered)
+                combined.append((layout.material, layout.width, 1.0 if self.result.linear else layout.height, layout.waste,
+                                 id, 1, [index], None))
+            else:
+                consumed[layout.input_index] += 1
+                active.setdefault(layout.input_index, []).append(index)
+        batches = list(combined)
+        for i, stock in enumerate(self.stocks):
+            layouts = active.get(i, [])
+            unused = (stock.count or 20000) - consumed[i]
+            count = max(0, unused) + len(layouts)
+            if count:
+                batches.append((stock.material, stock.width, stock.height, stock.waste, stock.id, count, layouts, i))
+        batches.sort(key=lambda b: (-b[0], -b[1] * b[2], b[1], -b[3]))
+        segments, mapping, start = [], {}, 0
+        for batch in batches:
+            segments.append((start, batch))
+            mapping.update((local, start + offset) for offset, local in enumerate(batch[6]))
+            start += batch[5]
+        self._inventory_cache = tuple(segments), mapping, start
+        return self._inventory_cache
+
+    def _component_id(self, component):
+        if component.id:
+            return component.id
+        return str(sum(stock.count or 20000 for stock in self.stocks[:component.input_index])
+                   + component.instance_index)
+
+    def _stock_id(self, stock, batch, local):
+        if batch[4] or batch[7] is None:
+            return batch[4]
+        input_index = batch[7]
+        base = sum(item.count or 20000 for item in self.stocks[:input_index])
+        if local is not None:
+            return str(base + self.result.layouts[local].instance_index)
+        start = next(start for start, candidate in self._inventory()[0] if candidate is batch)
+        offset = stock - start - len(batch[6])
+        used = {component.instance_index for layout in self.result.layouts for component in layout.components
+                if component.input_index == input_index}
+        used.update(layout.instance_index for layout in self.result.layouts
+                    if layout.input_index == input_index and len(layout.components) <= 1)
+        instance = 0
+        while instance in used or offset:
+            if instance not in used:
+                offset -= 1
+            instance += 1
+        return str(base + instance)
+
+    def _stock(self, index):
+        segments, _, total = self._inventory()
+        if self._result is None:
+            return None
+        if index < 0:
+            raise IndexError(index)
+        if index >= total:
+            return None
+        for start, batch in reversed(segments):
+            if index >= start:
+                offset = index - start
+                local = batch[6][offset] if offset < len(batch[6]) else None
+                return batch, local
+        return None
+
+    def _located(self, index):
+        if self._result is None or not 0 <= index < self.part_count:
+            return None
+        located = self.get_result_part(index)
+        return None if located is None else (self._inventory()[1][located[0]], located[1])
+
+    def _unplaced_values(self, index, name, n, flags):
+        # 原映射越界变为 -1，manager 再把 -1 映射至内部排序后的首件。
+        # 首件以已放置优先、原料序号、y、x 排序，不依赖特定订单或 ID。
+        locations = self._part_locations()
+        if 0 <= index < len(locations):
+            offset = index
+            for record in self.parts:
+                if offset < record.count:
+                    part = record
+                    width, height = record.width, record.height
+                    break
+                offset -= record.count
+        else:
+            placed = [(self._inventory()[1][value[0]], value[1].y, value[1].x, value[1])
+                      for value in locations if value is not None]
+            if placed:
+                placement = min(placed, key=lambda value: value[:3])[3]
+                part = self.parts[placement.input_index]
+                width, height = placement.width, placement.height
+                if self.result.linear:
+                    height = part.height
+            else:
+                candidates = [(record.rotatable, -max(record.width, record.height)
+                               if record.rotatable else -record.width,
+                               -min(record.width, record.height) if record.rotatable else -record.height,
+                               -i, record) for i, record in enumerate(self.parts) if record.count]
+                if not candidates:
+                    return None
+                part = min(candidates, key=lambda value: value[:4])[4]
+                width, height = part.width, part.height
+                if part.rotatable and height > width:
+                    width, height = height, width
+        if name == "GetResultPart":
+            return (-1, width, height, 0.0, 0.0, part.rotatable, part.id)[:n]
+        if n <= 4:
+            return (-1, width, 0.0, part.id)[:n]
+        values = (-1, width, part.angle_start, part.angle_end, 0.0, False)
+        return (*values, part.id) if n == 7 and flags.get("pdf_id") else (*values, False, part.id)[:n]
+
+    def _cut_values(self, cut, layout):
+        """匹配原结果缓冲区：直切是线段，型材斜切存 position/angle。"""
+        if self.result.linear:
+            if self._result_options.cross_section > 0:
+                angle = cut.angle
+                if angle == 90 and all(part.angle_start != 90 and part.angle_end != 90
+                                       for part in layout.parts):
+                    angle = 0.0
+                position = max(cut.x1, cut.x2) if angle > 90 else min(cut.x1, cut.x2)
+                return (position, angle, 0.0, 0.0, 0)
+            return (cut.x1, cut.y1, cut.x2, cut.y2, -1)
+        return (cut.x1, cut.y1, cut.x2, cut.y2, cut.level)
+
+    def _query(self, name, inputs, n, defaults, flags):
+        empty = (False, defaults)
+        if name == "GetMaterial":
+            index = inputs[0]
+            if index < 0:
+                raise IndexError(index)
+            if index >= len(self.materials):
+                return empty
+            m = self.materials[index]
+            return True, (m.id, m.description, m.thickness)
+        if self._result is None:
+            # 该返回值已经由原 DLL 所有执行前重载逐项测量。
+            return empty
+        mapping = self._inventory()[1]
+        if name in ("GetStockInfo", "GetLinearStockInfo"):
+            entry = self._stock(inputs[0])
+            if entry is None:
+                return empty
+            batch, local = entry
+            if local is not None:
+                layout = self.result.layouts[local]
+                width, height = layout.width, batch[2] if self.result.linear else layout.height
+            else:
+                width, height = batch[1:3]
+            id = self._stock_id(inputs[0], batch, local)
+            values = (width, height, local is not None, id) if name == "GetStockInfo" else (width, local is not None, id)
+            return True, values[:n]
+        if name == "GetLinearCombineStockInfo":
+            # 原方法先检查组件下标与全部库存数，再访问组合原料下标。
+            if inputs[1] >= self.StockCount:
+                return empty
+            if inputs[0] < 0 or inputs[0] >= self.StockCount:
+                raise IndexError(inputs[0])
+            entry = self._stock(inputs[0])
+            if entry is None or entry[1] is None:
+                return empty
+            components = sorted(self.result.layouts[entry[1]].components, key=lambda c: (c.width, c.input_index))
+            if len(components) > 1 and inputs[1] < 0:
+                raise IndexError(inputs[1])
+            if len(components) <= 1 or not 0 <= inputs[1] < len(components):
+                return empty
+            c = components[inputs[1]]
+            return True, (c.width, True, self._component_id(c))
+        if name == "GetLayoutInfo":
+            if not 0 <= inputs[0] < self.layout_count:
+                return empty
+            group = self.result.layout_groups[inputs[0]]
+            return True, (mapping[group.first_layout_index], group.layout_count)
+        if name in ("GetResultPart", "GetResultLinearPart"):
+            located = self._located(inputs[0])
+            if located is None:
+                values = self._unplaced_values(inputs[0], name, n, flags)
+                return (False, values) if values else empty
+            stock, p = located
+            if name == "GetResultPart":
+                # 原 GetResultPart 返回输入宽高，旋转由 aRotated 单独表示。
+                w, h = (p.height, p.width) if p.rotated and not self.result.linear else (p.width, p.height)
+                if self.result.linear:
+                    h = self.parts[p.input_index].height
+                return True, (stock, w, h, p.x, p.y, p.rotated, p.id)[:n]
+            if n <= 4:
+                return True, (stock, p.width, p.x, p.id)[:n]
+            values = (stock, p.width, p.angle_start, p.angle_end, p.x, p.rotated)
+            if n == 7 and flags.get("pdf_id"):
+                return True, (*values, p.id)
+            return True, (*values, p.flipped, p.id)[:n]
+        if name in ("GetRemainingPart", "GetRemainingLinearPart"):
+            remnants = self._remnants()
+            if not 0 <= inputs[0] < len(remnants):
+                if inputs[0] < 0:
+                    raise IndexError(inputs[0])
+                return empty
+            stock, r = remnants[inputs[0]]
+            width, x, angle = r.width, r.x, r.angle
+            if self.result.linear and self._result_options.cross_section > 0:
+                parts = self.result.layouts[stock].parts
+                if parts:
+                    last = max(parts, key=lambda part: part.x + part.width)
+                    if last.angle_end % 90:
+                        overlap = abs(self._result_options.cross_section / tan(radians(last.angle_end)))
+                        width, x = width + overlap, x - overlap
+                    angle = last.angle_end
+            values = ((mapping[stock], width, 1.0 if self.result.linear else r.height, x, r.y) if name == "GetRemainingPart"
+                      else (mapping[stock], width, x, angle))
+            return True, values[:n]
+        if name in ("GetCut", "GetLinearCut"):
+            cuts = self._cuts()
+            if not 0 <= inputs[0] < len(cuts):
+                return empty
+            stock, cut = cuts[inputs[0]]
+            segment = self._cut_values(cut, self.result.layouts[stock])
+            values = ((mapping[stock], *segment[:2]) if name == "GetLinearCut" else
+                      (mapping[stock], *segment))
+            return True, values[:n]
+        if name == "GetPartCut":
+            if not 0 <= inputs[0] < self.part_count:
+                return empty
+            if self.result.linear:
+                # 原版此路径空引用异常；纯 Python 保留安全的 false，差异报告单独列出。
+                return empty
+            stock, cuts = self._part_cuts(inputs[0])
+            if inputs[1] < 0 and cuts:
+                raise IndexError(inputs[1])
+            if not 0 <= inputs[1] < len(cuts):
+                return empty
+            c = cuts[inputs[1]]
+            return True, (mapping[stock], c.x1, c.y1, c.x2, c.y2)
+        if inputs[0] < 0:
+            return empty
+        entry = self._stock(inputs[0])
+        if entry is None or entry[1] is None:
+            return empty
+        layout = self.result.layouts[entry[1]]
+        cuts = layout.trim_cuts if name == "GetStockTrimCut" else layout.cuts
+        if inputs[1] < 0 and cuts:
+            raise IndexError(inputs[1])
+        if not 0 <= inputs[1] < len(cuts):
+            return empty
+        c = cuts[inputs[1]]
+        segment = self._cut_values(c, layout)
+        values = segment[:2] if name == "GetLinearStockCut" else segment
+        return True, values[:n]
+
+    @property
+    def StockCount(self):
+        return self._inventory()[2]
+
+    LinearStockCount = StockCount
+
+    @property
+    def UsedStockCount(self):
+        return len(self._result.layouts) if self._result else 0
+
+    UsedLinearStockCount = UsedStockCount
+
+    @property
+    def RemainingPartCount(self):
+        return self.remaining_part_count if self._result is not None else 0
+
+    @property
+    def LayoutCount(self):
+        return self.layout_count if self._result is not None else 0
+
+    @property
+    def PlacedPartCount(self):
+        return self.placed_part_count if self._result is not None else 0
+
+    @property
+    def ElapsedTime(self):
+        return self.elapsed_time if self._result is not None else 0.0
+
+    def GetPartMaterial(self, part):
+        if self._result is None or not 0 <= part < self.part_count:
+            return -1
+        return self.get_part_material(part)
+
+    def GetStockMaterial(self, stock):
+        entry = self._stock(stock)
+        return entry[0][0] if entry else -1
+
+    def GetRemainingPartMaterial(self, part):
+        if self._result is None:
+            return -1
+        if not 0 <= part < self.remaining_part_count:
+            raise IndexError(part)
+        return self.get_remaining_part_material(part)
+
+    def GetLayoutFillRatio(self, layout):
+        return self.get_layout_fill_ratio(layout) if self._result and 0 <= layout < self.layout_count else 0.0
+
+    def GetPartCountOnStock(self, stock):
+        if stock < 0:
+            return 0
+        entry = self._stock(stock)
+        return len(self.result.layouts[entry[1]].parts) if entry and entry[1] is not None else 0
+
+    def GetPartIndexOnStock(self, stock, part):
+        if stock < 0:
+            return -1
+        entry = self._stock(stock)
+        if not entry or entry[1] is None or not 0 <= part < len(self.result.layouts[entry[1]].parts):
+            return -1
+        return self.get_part_index_on_stock(entry[1], part)
+
+    def GetRemainingPartCountOnStock(self, stock):
+        if stock < 0:
+            return 0
+        entry = self._stock(stock)
+        return len(self.result.layouts[entry[1]].all_remnants) if entry and entry[1] is not None else 0
+
+    def GetRemainingPartIndexOnStock(self, stock, part):
+        if stock < 0:
+            return -1
+        entry = self._stock(stock)
+        if not entry or entry[1] is None or not 0 <= part < len(self.result.layouts[entry[1]].all_remnants):
+            return -1
+        return self.get_remaining_part_index_on_stock(entry[1], part)
+
+    def GetLinearCombineStockCount(self, stock):
+        entry = self._stock(stock)
+        return self.get_linear_combine_stock_count(entry[1]) if entry and entry[1] is not None else 0
+
+    def GetPartCutsCount(self, part):
+        return self.get_part_cuts_count(part) if self._result and not self.result.linear and 0 <= part < self.part_count else 0
+
+    def GetCutsCount(self):
+        return self.get_cuts_count() if self._result else 0
+
+    GetLinearCutsCount = GetCutsCount
+
+    def GetStockCutCount(self, stock):
+        if stock < 0:
+            return 0
+        entry = self._stock(stock)
+        return self.get_stock_cut_count(entry[1]) if entry and entry[1] is not None else 0
+
+    def GetStockTrimCutCount(self, stock):
+        if stock < 0:
+            return 0
+        entry = self._stock(stock)
+        return self.get_stock_trim_cut_count(entry[1]) if entry and entry[1] is not None else 0
+
+    def _export(self, method, target, *args, **kwargs):
+        if method == "export_ptx" and self._result and self.result.linear:
+            return False
+        # 文件系统/不可写流异常按原版传播，不把 IO 错误伪装成 false。
+        if self._result is None:
+            return False
+        if target is None:
+            raise TypeError("导出目标不能为 None")
+        getattr(self, method)(target, *args, **kwargs)
+        return True
+
+    def ExportToCSV(self, target):
+        return self._export("export_csv", target)
+
+    ExportToCSV_Stream = ExportToCSV
+
+    def ExportToDXF(self, target, include_part_ids):
+        return self._export("export_dxf", target, include_part_ids)
+
+    ExportToDXF_Stream = ExportToDXF
+
+    def ExportCutsToDXF(self, target, include_cut_number, include_stock_panel):
+        return self._export("export_cuts_dxf", target, include_cut_number, include_stock_panel)
+
+    ExportCutsToDXF_Stream = ExportCutsToDXF
+
+    def ExportToPTX(self, target, job, customer, material, thickness, units, scale, require_all_trim_cuts=False):
+        return self._export("export_ptx", target, job, customer, material, thickness, units, scale, require_all_trim_cuts)
+
+    def ExportToPTX_Stream(self, target, *args):
+        if len(args) == 6:
+            # 原七参数流重载的顺序与文件重载不同，默认保留全部修边。
+            job, material, thickness, customer, units, scale = args
+            return self.ExportToPTX(target, job, customer, material, thickness, units, scale, True)
+        if len(args) == 7:
+            return self.ExportToPTX(target, *args)
+        raise TypeError("ExportToPTX_Stream 需要六个或七个任务参数")
+
+    def _create_image(self, stock, target, max_size, linear, stream=False):
+        if not stream and not hasattr(target, "write"):
+            # 原文件入口先创建文件，再查询原料；无结果时也会留下空文件。
+            with open(target, "wb") as destination:
+                return self._create_image(stock, destination, max_size, linear, stream=True)
+        entry = self._stock(stock)
+        if entry is None:
+            return False
+        if target is None:
+            raise TypeError("图片输出流不能为 None")
+        batch, local = entry
+        layout = self.result.layouts[local] if local is not None else Layout(
+            -1, stock, batch[1], batch[2], batch[4], batch[0], batch[3])
+        if self.result.linear:
+            layout = replace(layout, height=batch[2])
+        from .exporters import render_png
+        target.write(render_png(layout, linear=linear, max_size=min(4000, max(50, max_size))))
+        return True
+
+    def CreateStockImage(self, stock, target, max_size=1000):
+        return self._create_image(stock, target, max_size, False)
+
+    def CreateStockImage_Stream(self, stock, target, max_size=1000):
+        return self._create_image(stock, target, max_size, False, stream=True)
+
+    def CreateLinearStockImage(self, stock, target, max_size=1000):
+        return self._create_image(stock, target, max_size, True)
+
+    def CreateLinearStockImage_Stream(self, stock, target, max_size=1000):
+        return self._create_image(stock, target, max_size, True, stream=True)
+
+
+def _query_method(name, input_count, variants):
+    def method(self, *args, include_id=False, include_angles=False, include_angle=False,
+               with_level=False, include_flipped=True):
+        if len(args) < input_count:
+            raise TypeError(f"{name} 缺少输入参数")
+        inputs, outputs = args[:input_count], args[input_count:]
+        n = len(outputs) if outputs else min(variants)
+        if not outputs:
+            if name == "GetResultLinearPart" and include_angles:
+                n = (7 if include_flipped else 6) + bool(include_id)
+            elif include_id or include_angle or with_level:
+                n += 1
+        if n not in variants:
+            raise TypeError(f"{name} 不支持 {n} 个 out 参数")
+        flags = {"pdf_id": name == "GetResultLinearPart" and n == 7 and
+                 ((outputs and isinstance(outputs[-1].value, str)) or not include_flipped)}
+        defaults = variants[n]
+        if flags["pdf_id"]:
+            defaults = (*defaults[:-1], "")
+        success, values = self._query(name, inputs, n, defaults, flags)
+        return _answer(outputs, success, values)
+    method.__name__ = name
+    method.__doc__ = f"手册 {name}；支持 Out 引用或返回 (成功标志, 输出值...)。"
+    return method
+
+
+for _name, (_inputs, _variants) in _QUERIES.items():
+    setattr(CutGLibEngine, _name, _query_method(_name, _inputs, _variants))