ecode-cutting 0.2.3__py3-none-any.whl

ecode_cutting/_common.py

@@ -0,0 +1,158 @@
+"""输入校验、精度处理和合作式取消；不保存跨任务可变状态。"""
+
+from __future__ import annotations
+
+from dataclasses import fields, replace
+from decimal import Decimal, InvalidOperation, ROUND_HALF_EVEN
+from math import isfinite
+from sys import float_info
+from time import monotonic
+from typing import Callable, Sequence
+
+from .models import Options, Part, Progress, Stock, ValidationError
+
+
+def number(value: object, name: str, *, positive: bool = False) -> float:
+    if isinstance(value, (str, bytes, bool)):
+        raise ValidationError(f"{name} 必须是有限数值")
+    try:
+        result = float(value)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise ValidationError(f"{name} 必须是有限数值") from exc
+    if not isfinite(result) or result < 0 or (positive and result == 0):
+        raise ValidationError(f"{name} 必须是{'正' if positive else '非负'}有限数值")
+    return result
+
+
+def integer(value: object, name: str, minimum: int = 0) -> int:
+    if type(value) is not int or value < minimum:
+        raise ValidationError(f"{name} 必须是大于等于 {minimum} 的整数")
+    return value
+
+
+def quantize(value: float, precision: int) -> int:
+    """与 .NET 默认舍入一致，避免二进制浮点数在锯缝边界积累误差。"""
+    try:
+        return int((Decimal(str(value)) * (10 ** precision)).to_integral_value(rounding=ROUND_HALF_EVEN))
+    except (InvalidOperation, ValueError, OverflowError) as exc:
+        raise ValidationError("尺寸超出可表示范围") from exc
+
+
+def matches(stock_material: int, part_material: int) -> bool:
+    # -1 原料是通配材料；指定材料的原料不能接收未指定材料的零件。
+    return stock_material == -1 or stock_material == part_material
+
+
+def normalize_options(options: Options) -> Options:
+    """计算边界统一为有限 float，避免 Decimal 与内部浮点计时混算。"""
+    if not isinstance(options, Options):
+        raise ValidationError("options 必须是 Options")
+    values = {}
+    for f in fields(options):
+        if isinstance(f.default, float):
+            value = getattr(options, f.name)
+            values[f.name] = None if f.name == "time_limit" and value is None else number(value, f.name)
+    return replace(options, **values)
+
+
+def validate(stocks: Sequence[Stock], parts: Sequence[Part], options: Options, *, linear: bool) -> None:
+    if not isinstance(options, Options):
+        raise ValidationError("options 必须是 Options")
+    for name in ("saw_width", "trim_left", "trim_right", "trim_top", "trim_bottom", "waste_size_min", "cross_section"):
+        number(getattr(options, name), name)
+    for name in ("max_cut_level", "max_layout_size", "linear_max_size_per_stock"):
+        integer(getattr(options, name), name)
+    integer(options.max_size_per_stock, "max_size_per_stock", -1)
+    integer(options.max_decimal_point, "max_decimal_point")
+    if options.max_decimal_point > 6:
+        raise ValidationError("max_decimal_point 必须在 0 到 6 之间")
+    integer(options.max_attempts, "max_attempts", 1)
+    integer(options.seed, "seed")
+    threshold = number(options.linear_max_size_per_stock_threshold, "linear_max_size_per_stock_threshold")
+    if threshold > 1:
+        raise ValidationError("linear_max_size_per_stock_threshold 必须在 0 到 1 之间")
+    if options.cut_direction not in ("auto", "horizontal", "vertical"):
+        raise ValidationError("cut_direction 必须是 auto、horizontal 或 vertical")
+    if options.roll_mode and (linear or options.cut_direction == "auto"):
+        raise ValidationError("卷材模式必须显式选择二维横向或纵向切割")
+    if options.time_limit is not None:
+        number(options.time_limit, "time_limit")
+    for f in fields(options):
+        if isinstance(f.default, bool) and type(getattr(options, f.name)) is not bool:
+            raise ValidationError(f"{f.name} 必须是布尔值")
+    requested = sum(integer(p.count, "parts.count") for p in parts if isinstance(p, Part))
+    for kind, items in (("stocks", stocks), ("parts", parts)):
+        total_area = total_quantized_area = 0
+        for i, item in enumerate(items):
+            if not isinstance(item, Stock if kind == "stocks" else Part):
+                raise ValidationError(f"{kind}[{i}] 类型错误")
+            dimensions, quantized_dimensions = [], []
+            for dim in ("width", "height"):
+                value = number(getattr(item, dim), f"{kind}[{i}].{dim}", positive=True)
+                rounded = quantize(value, options.max_decimal_point)
+                if rounded <= 0:
+                    raise ValidationError(f"{kind}[{i}].{dim} 在当前精度下为零")
+                dimensions.append(value)
+                quantized_dimensions.append(rounded)
+            integer(item.count, f"{kind}[{i}].count")
+            integer(item.material, f"{kind}[{i}].material", -1)
+            # 按实际浮点表示能力限制，而不规定业务尺寸上限；包含精度缩放后的中间量。
+            quantity = item.count or (max(1, requested) if kind == "stocks" else 0)
+            area = dimensions[0] * dimensions[1]
+            quantized_area = quantized_dimensions[0] * quantized_dimensions[1]
+            if linear and options.cross_section:
+                area = max(area, dimensions[0] * number(options.cross_section, "cross_section"))
+                quantized_area = max(quantized_area, quantized_dimensions[0] * quantize(options.cross_section, options.max_decimal_point))
+            try:
+                total_area += area * quantity
+                total_quantized_area += quantized_area * quantity
+            except OverflowError as exc:
+                raise ValidationError(f"{kind} 总材料尺寸超出浮点表示范围") from exc
+            if (not isfinite(area) or not isfinite(total_area)
+                    or max(quantized_dimensions) > float_info.max
+                    or total_quantized_area > float_info.max):
+                raise ValidationError(f"{kind} 面积或精度缩放后的总材料尺寸超出浮点表示范围")
+            if not isinstance(item.id, str):
+                raise ValidationError(f"{kind}[{i}].id 必须是字符串")
+            if isinstance(item, Part):
+                if type(item.rotatable) is not bool:
+                    raise ValidationError("rotatable 必须是布尔值")
+                for angle in (item.angle_start, item.angle_end):
+                    number(angle, "angle")
+                    if angle != 0 and not 10 <= angle <= 170:
+                        raise ValidationError("切角必须是 0 或 10 到 170 度")
+                    if not linear and angle != 0:
+                        raise ValidationError("斜角仅适用于一维型材")
+            elif type(item.waste) is not bool:
+                raise ValidationError("waste 必须是布尔值")
+    if linear and any(p.angle_start or p.angle_end for p in parts) and options.cross_section <= 0:
+        raise ValidationError("斜角切割必须设置正的 cross_section")
+
+
+class Runtime:
+    """回调返回 True 时取消；超时或取消后仍返回已经得到的可行解。"""
+
+    def __init__(self, options: Options, requested: int, callback: Callable[[Progress], bool] | None = None):
+        self.started = monotonic()
+        self.deadline = None if options.time_limit is None else self.started + number(options.time_limit, "time_limit")
+        self.callback = callback
+        self.requested = requested
+        self.cancelled = False
+        self.timed_out = False
+        self.last_callback = -1.0
+
+    @property
+    def elapsed(self) -> float:
+        return monotonic() - self.started
+
+    def stopped(self, placed: int = 0, attempt: int = 0) -> bool:
+        if self.cancelled or self.timed_out:
+            return True
+        now = monotonic()
+        if self.deadline is not None and now >= self.deadline:
+            self.timed_out = True
+            return True
+        if self.callback is not None and now - self.last_callback >= 0.02:
+            self.last_callback = now
+            self.cancelled = bool(self.callback(Progress(now - self.started, placed, self.requested, attempt)))
+        return self.cancelled

ecode_cutting/_linear_fast.py

@@ -0,0 +1,231 @@
+"""直端批量订单的容量索引；复杂约束交还完整的一维求解器。"""
+
+from __future__ import annotations
+
+from bisect import bisect_left, insort
+from collections import Counter, defaultdict
+from dataclasses import replace
+from math import hypot
+from random import Random
+from typing import Sequence
+
+from ._common import Runtime, matches, quantize
+from .linear import _Bar, solve_linear
+from .models import (Cut, Layout, Options, Part, Placement, Remnant, Result,
+                     Stock, StockComponent, Unplaced, ValidationError)
+
+
+def solve_linear_fast(stocks: Sequence[Stock], parts: Sequence[Part], options: Options,
+                      runtime: Runtime) -> Result:
+    """保持原启发式的候选顺序，仅替换逐棒扫描；输入校验由引擎负责。"""
+    requested = sum(p.count for p in parts)
+    if (requested <= 64 or options.waste_size_min or options.linear_max_size_per_stock
+            or options.max_size_per_stock
+            or any(p.angle_start not in (0, 90) or p.angle_end not in (0, 90) for p in parts)):
+        return solve_linear(stocks, parts, options, runtime)
+
+    scale = 10 ** options.max_decimal_point
+    q = lambda n: quantize(n, options.max_decimal_point)
+    widths, stock_widths = [q(p.width) for p in parts], [q(s.width) for s in stocks]
+    left, right, kerf = map(q, (options.trim_left, options.trim_right, options.saw_width))
+    keys = [(w, 0, 0) for w in widths]
+    instances = [(i, j) for i, p in enumerate(parts) for j in range(p.count)]
+    stock_order = sorted(range(len(stocks)), key=lambda j: (
+        not stocks[j].waste, -stock_widths[j] if options.use_large_stock_first else stock_widths[j], j))
+    best, best_score, attempts = [], None, 0
+
+    def score(bars):
+        cut_count = sum(len(b.items) + 1
+                        - (b.items[0][2] in (0, left))
+                        - (b.end in (b.width, b.width - right))
+                        + bool(left) + bool(right) for b in bars)
+        patterns = (len({(b.width, tuple(sorted(b.types.items()))) for b in bars})
+                    if options.use_layout_minimization else 0)
+        return (-sum(len(b.items) for b in bars), len(bars), sum(not b.waste for b in bars),
+                patterns, sum(b.width for b in bars), cut_count)
+
+    def remember(bars):
+        nonlocal best, best_score
+        candidate = score(bars)
+        if best_score is None or candidate < best_score:
+            best, best_score = [b.copy() for b in bars], candidate
+
+    def append(bar, i, instance):
+        x = bar.end + kerf if bar.items else left
+        bar.items.append((i, instance, x, 0, 0, False, False))
+        bar.end = x + widths[i]
+        bar.types[keys[i]] += 1
+
+    if not runtime.stopped() and options.complete_mode:
+        for i, part in enumerate(parts):
+            if part.count and not any(matches(s.material, part.material)
+                                      and stock_widths[j] - left - right >= widths[i]
+                                      for j, s in enumerate(stocks)):
+                if runtime.stopped():
+                    break
+                raise ValidationError(f"parts[{i}] 无法放入任何可用原料（含修边、余料和组合约束）")
+
+    rng = Random(options.seed)
+    for attempt in range(1 if options.linear_sort_ascending else options.max_attempts):
+        if runtime.stopped(-best_score[0] if best_score else 0, attempt):
+            break
+        attempts += 1
+        order = instances.copy()
+        if options.linear_sort_ascending or attempt == 1:
+            order.sort(key=lambda item: widths[item[0]])
+        elif attempt == 0:
+            order.sort(key=lambda item: widths[item[0]], reverse=True)
+        else:
+            rng.shuffle(order)
+        bars, used = [], Counter()
+        buckets = defaultdict(list)
+        for position, (i, instance) in enumerate(order):
+            if position % 32 == 0 and runtime.stopped(position, attempt + 1):
+                break
+            materials = (-1,) if parts[i].material == -1 else (-1, parts[i].material)
+            candidate = None
+            for waste in (True, False):
+                for material in materials:
+                    bucket = buckets[material, waste]
+                    index = bisect_left(bucket, (widths[i], -1))
+                    if index < len(bucket):
+                        capacity, j = bucket[index]
+                        choice = (capacity, j, material, waste, index)
+                        if candidate is None or choice[:2] < candidate[:2]:
+                            candidate = choice
+                if candidate is not None:
+                    break
+            if candidate is not None:
+                _, j, material, waste, index = candidate
+                buckets[material, waste].pop(index)
+                bar = bars[j]
+            else:
+                stock_i = next((j for j in stock_order
+                                if (not stocks[j].count or used[j] < stocks[j].count)
+                                and matches(stocks[j].material, parts[i].material)
+                                and stock_widths[j] - left - right >= widths[i]), None)
+                if stock_i is None:
+                    continue
+                stock = stocks[stock_i]
+                bar = _Bar(((stock_i, used[stock_i]),), stock_widths[stock_i],
+                           stock.material, stock.waste, end=left)
+                used[stock_i] += 1
+                j = len(bars)
+                bars.append(bar)
+            append(bar, i, instance)
+            capacity = bar.width - right - bar.end - kerf
+            if capacity >= 0:
+                # ponytail: bisect 定位后列表移动仍为 O(B)，避免逐棒执行 Python fit 循环。
+                insort(buckets[bar.material, bar.waste], (capacity, j))
+        remember(bars)
+
+    # 与原求解器同样的小组重排；多材料大订单也可能含一个小材料组。
+    capacity = max(stock_widths, default=0) - left - right + kerf
+    lower_bound = ((sum((widths[i] + kerf) * p.count for i, p in enumerate(parts))
+                    + capacity - 1) // capacity if capacity > 0 else 0)
+    nodes, changed = 0, True
+    while (changed and best and -best_score[0] == requested and best_score[1] != lower_bound
+           and not runtime.stopped(requested, attempts)):
+        changed = False
+        for removed in sorted(range(len(best)), key=lambda j: best[j].end):
+            group = [j for j, b in enumerate(best) if b.material == best[removed].material]
+            items = [(item[0], item[1]) for j in group for item in best[j].items]
+            if len(group) < 2 or len(group) > 8 or len(items) > 64:
+                continue
+            targets = [replace(best[j], items=[], types=Counter(), end=left)
+                       for j in group if j != removed]
+            if sum(widths[i] + kerf for i, _ in items) > sum(b.width - left - right + kerf for b in targets):
+                continue
+            items.sort(key=lambda item: widths[item[0]], reverse=not options.linear_sort_ascending)
+            seen, local_nodes = set(), 0
+
+            def assign(position):
+                nonlocal nodes, local_nodes
+                nodes += 1
+                local_nodes += 1
+                if local_nodes > 20000 or nodes > 100000:
+                    return False
+                if nodes % 64 == 0 and runtime.stopped(requested, attempts):
+                    return False
+                if position == len(items):
+                    return all(b.items for b in targets)
+                state = (position, tuple((b.end, tuple(sorted(b.types.items()))) for b in targets))
+                if state in seen:
+                    return False
+                seen.add(state)
+                i, instance = items[position]
+                symmetric = set()
+                for j in sorted(range(len(targets)), key=lambda j: targets[j].width - targets[j].end):
+                    bar = targets[j]
+                    signature = (bar.width, bar.waste, bar.end, tuple(sorted(bar.types.items())))
+                    if signature in symmetric:
+                        continue
+                    symmetric.add(signature)
+                    x = bar.end + kerf if bar.items else left
+                    if not matches(bar.material, parts[i].material) or x + widths[i] > bar.width - right:
+                        continue
+                    saved = bar.copy()
+                    append(bar, i, instance)
+                    if assign(position + 1):
+                        return True
+                    targets[j] = saved
+                return False
+
+            if assign(0):
+                remember([b for j, b in enumerate(best) if j not in group] + targets)
+                changed = True
+                break
+            if nodes > 100000 or runtime.stopped(requested, attempts):
+                changed = False
+                break
+
+    layouts, placed_counts, stock_instances = [], Counter(), Counter()
+    for bar in best:
+        stock_i = bar.components[0][0]
+        stock, instance = stocks[stock_i], stock_instances[stock_i]
+        stock_instances[stock_i] += 1
+        height = options.cross_section or stock.height
+        placements, cuts = [], []
+        previous_end = None
+        for local_index, (i, _, integer_x, *_rest) in enumerate(bar.items):
+            part = parts[i]
+            x, width = integer_x / scale, widths[i] / scale
+            placements.append(Placement(i, placed_counts[i], width, height, x, id=part.id,
+                                        material=part.material, angle_start=part.angle_start,
+                                        angle_end=part.angle_end))
+            placed_counts[i] += 1
+            for is_start, top, angle in ((True, x, part.angle_start),
+                                          (False, x + width, part.angle_end)):
+                if abs(top) < 1e-9 or abs(top - bar.width / scale) < 1e-9:
+                    continue
+                if is_start and local_index == 0 and abs(top - left / scale) < 1e-9 and left:
+                    continue
+                if not is_start and abs(top - (bar.width - right) / scale) < 1e-9 and right:
+                    continue
+                allowance = kerf / scale * hypot(height, 0) / (2 * height)
+                shift = -allowance if is_start else allowance
+                cut = Cut(top + shift, 0, top + shift, height, angle=angle or 90,
+                          part_indices=(local_index,))
+                if is_start and previous_end is not None and abs(cuts[previous_end].x1 - cut.x1) <= 1e-9:
+                    old = cuts[previous_end]
+                    cuts[previous_end] = replace(old, x1=(old.x1 + cut.x1) / 2,
+                                                 x2=(old.x2 + cut.x2) / 2,
+                                                 part_indices=old.part_indices + (local_index,))
+                else:
+                    cuts.append(cut)
+                    if not is_start:
+                        previous_end = len(cuts) - 1
+        remnant_x = min(bar.width - right, bar.end + kerf) if bar.end < bar.width - right else bar.end
+        remnant_width = max(0, bar.width - right - remnant_x)
+        remnants = ((Remnant(remnant_width / scale, height, remnant_x / scale, material=bar.material),)
+                    if remnant_width else ())
+        trim_cuts = tuple(Cut(x / scale, 0, x / scale, height)
+                          for x, trim in ((left - kerf / 2, left),
+                                          (bar.width - right + kerf / 2, right)) if trim)
+        component = StockComponent(stock_i, instance, stock_widths[stock_i] / scale,
+                                   stock.id, stock.waste, stock.material)
+        layouts.append(Layout(stock_i, instance, bar.width / scale, height, stock.id, bar.material,
+                              bar.waste, tuple(placements), remnants, tuple(cuts), trim_cuts, (component,)))
+    return Result(tuple(layouts), tuple(Unplaced(i, p.count - placed_counts[i], p.id)
+                                       for i, p in enumerate(parts) if p.count > placed_counts[i]),
+                  runtime.elapsed, True, runtime.cancelled, runtime.timed_out, attempts)