ecode-cutting 0.2.3__py3-none-any.whl

ecode_cutting/linear.py

@@ -0,0 +1,532 @@
+"""一维型材排样：整数长度、真实斜切轮廓及按需组合原料。"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field, replace
+from heapq import heappop, heappush
+from math import ceil, hypot, radians, tan
+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, StockComponent, Unplaced, ValidationError)
+
+
+@dataclass
+class _Bar:
+    components: tuple[tuple[int, int], ...]
+    width: int
+    material: int
+    waste: bool
+    # 每项保存输入件、实例、包围盒起点、两端偏移、镜像、反向。
+    items: list[tuple[int, int, int, int, int, bool, bool]] = field(default_factory=list)
+    end: int = 0
+    types: Counter = field(default_factory=Counter)
+
+    def copy(self):
+        return replace(self, items=self.items.copy(), types=self.types.copy())
+
+
+def _polygon(x: float, width: float, height: float, start: float, end: float):
+    """斜端线裁剪包围矩形；短件端线相交时自然得到三角形。"""
+    points = [(x, 0.0), (x + width, 0.0), (x + width, height), (x, height)]
+    for offset, left in ((start, True), (end, False)):
+        def distance(p):
+            line = (x + max(offset, 0) - offset * p[1] / height if left else
+                    x + width + min(offset, 0) - offset * p[1] / height)
+            return p[0] - line if left else line - p[0]
+        clipped = []
+        for a, b in zip(points, points[1:] + points[:1]):
+            da, db = distance(a), distance(b)
+            if da >= -1e-10:
+                clipped.append(a)
+            if (da < 0) != (db < 0):
+                t = da / (da - db)
+                clipped.append((a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])))
+        points = []
+        for point in clipped:
+            if not points or any(abs(a - b) > 1e-9 for a, b in zip(point, points[-1])):
+                points.append(point)
+        if len(points) > 1 and all(abs(a - b) < 1e-9 for a, b in zip(points[0], points[-1])):
+            points.pop()
+    return tuple(points)
+
+
+def solve_linear(stocks: Sequence[Stock], parts: Sequence[Part], options: Options,
+                 runtime: Runtime) -> Result:
+    scale = 10 ** options.max_decimal_point
+    q = lambda n: quantize(n, options.max_decimal_point)
+    widths = [q(p.width) for p in parts]
+    stock_widths = [q(s.width) for s in stocks]
+    left, right, kerf, minimum = map(q, (options.trim_left, options.trim_right,
+                                       options.saw_width, options.waste_size_min))
+    section = q(options.cross_section)
+
+    def bevel(angle):
+        if not angle or angle == 90:
+            return 0
+        value = section / tan(radians(angle))
+        # 原库斜端偏移取远离零的中点舍入。
+        return int(value + .5) if value >= 0 else -int(-value + .5)
+
+    offsets = [(bevel(p.angle_start), bevel(p.angle_end)) for p in parts]
+    keys = [(widths[i], *offsets[i]) for i in range(len(parts))]
+    demand = Counter()
+    for i, p in enumerate(parts):
+        demand[keys[i]] += p.count
+    requested = sum(p.count for p in parts)
+    instances = [(i, j) for i, p in enumerate(parts) for j in range(p.count)]
+    best: list[_Bar] = []
+    best_score = None
+    attempts = 0
+    # 仅直端、无拼接时计入每根的修边与锯缝；其它情形不猜测容量下界。
+    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 and not options.max_size_per_stock
+                   and not any(a or b for a, b in offsets) else 0)
+
+    def count_bound_reached():
+        return best_score is not None and -best_score[0] == requested and best_score[1] == lower_bound
+
+    def axial_kerf(offset):
+        # 以最终整数轮廓的真实切线换算法向锯缝，避免精度量化后几何不一致。
+        return ceil(kerf * hypot(section, offset) / section - 1e-9) if section else kerf
+
+    def tail(bar):
+        if not bar.items or bar.end >= bar.width - right:
+            return bar.end, 0
+        x = min(bar.width - right, bar.end + axial_kerf(bar.items[-1][4]))
+        return x, bar.width - right - x
+
+    def valid_tail(bar):
+        remaining = tail(bar)[1]
+        return remaining == 0 or remaining >= minimum
+
+    def finish_bars(bars):
+        # 中间状态可暂时留下小余料；最终未能填满时撤回尾件，保留合法前缀。
+        finished = []
+        for original in bars:
+            bar = original.copy()
+            while bar.items and not valid_tail(bar):
+                i, *_ = bar.items.pop()
+                bar.types[keys[i]] -= 1
+                if not bar.types[keys[i]]:
+                    del bar.types[keys[i]]
+                bar.end = max((item[2] + widths[item[0]] for item in bar.items), default=left)
+            if bar.items:
+                finished.append(bar)
+        return finished
+
+    def available(i, used):
+        return stocks[i].count == 0 or used[i] < stocks[i].count
+
+    def make_bar(components, used):
+        seen = used.copy()
+        refs = []
+        for i in components:
+            refs.append((i, seen[i]))
+            seen[i] += 1
+        materials = {stocks[i].material for i in components if stocks[i].material != -1}
+        return _Bar(tuple(refs), sum(stock_widths[i] for i in components),
+                    next(iter(materials), -1), any(stocks[i].waste for i in components), end=left)
+
+    def combination(part_index, used):
+        """最短覆盖组合；库存仅保存计数，绝不展开无限原料。"""
+        if not options.max_size_per_stock:
+            return None
+        required = widths[part_index] + left + right
+        final_kerf = min((axial_kerf(item[1]) for item in orientation_choices[part_index]), default=kerf)
+        candidates = [i for i, s in enumerate(stocks)
+                      if available(i, used) and matches(s.material, parts[part_index].material)]
+        if not candidates:
+            return None
+        # 同长度原料可直接整除/向上取整，常见的无限库存不进入子集枚举。
+        fallback = None
+        groups = {}
+        for i in candidates:
+            group = (stock_widths[i], None if options.allow_combine_stock_regular_and_waste else stocks[i].waste)
+            groups.setdefault(group, []).append(i)
+        for (width, _), group in groups.items():
+            quantity = (required + width - 1) // width
+            remainder = quantity * width - required
+            if final_kerf < remainder < minimum + final_kerf:
+                quantity = (required + minimum + final_kerf + width - 1) // width
+            selected = []
+            for i in sorted(group, key=lambda j: not stocks[j].waste):
+                take = quantity - len(selected)
+                if stocks[i].count:
+                    take = min(take, stocks[i].count - used[i])
+                selected.extend([i] * take)
+                if len(selected) == quantity:
+                    bar = make_bar(selected, used)
+                    if fallback is None or (bar.width, len(bar.components), not bar.waste) < (fallback.width, len(fallback.components), not fallback.waste):
+                        fallback = bar
+                    break
+        if fallback is not None and (fallback.width == required or options.max_size_per_stock == 1):
+            return fallback
+        if options.max_size_per_stock == 1:
+            return None
+        upper = required + minimum + final_kerf + max(stock_widths[i] for i in candidates)
+        if fallback is not None:
+            upper = min(upper, fallback.width)
+        queue = [(0, (), ())]
+        seen = set()
+        visits = 0
+        while queue:
+            length, components, lengths = heappop(queue)
+            visits += 1
+            if visits % 64 == 0 and runtime.stopped():
+                return fallback
+            remainder = length - required
+            if length >= required and (remainder <= final_kerf or remainder >= minimum + final_kerf):
+                return make_bar(components, used)
+            for i in candidates:
+                if components and i < components[-1]:
+                    continue
+                if not options.allow_combine_stock_regular_and_waste and components and stocks[i].waste != stocks[components[0]].waste:
+                    continue
+                if stocks[i].count and used[i] + components.count(i) >= stocks[i].count:
+                    continue
+                new_lengths = tuple(sorted(set(lengths + (stock_widths[i],))))
+                if options.max_size_per_stock > 0 and len(new_lengths) > options.max_size_per_stock:
+                    continue
+                new_length = length + stock_widths[i]
+                new_components = components + (i,)
+                state = (new_components, new_lengths)
+                if new_length <= upper and state not in seen:
+                    seen.add(state)
+                    heappush(queue, (new_length, new_components, new_lengths))
+        return fallback
+
+    def build_orientations(i):
+        a, b = offsets[i]
+        result = [(a, b, False, False)]
+        if options.linear_allow_rotate:
+            result.append((-a, -b, True, False))
+        if options.linear_allow_flipping:
+            result.append((-b, -a, False, True))
+            if options.linear_allow_rotate:
+                result.append((b, a, True, True))
+        # 相同斜率的两端可能完全吃掉短件；不能输出空轮廓冒充成品。
+        return [item for item in dict.fromkeys(result)
+                if max(widths[i] + min(item[1], 0) - max(item[0], 0),
+                       widths[i] - max(item[1], 0) - max(-item[0], 0)) > 0]
+
+    orientation_choices = [build_orientations(i) for i in range(len(parts))]
+
+    def fit(bar, i, counts, *, check_remnant=False):
+        if not matches(bar.material, parts[i].material):
+            return None
+        if options.linear_max_size_per_stock and keys[i] not in bar.types and len(bar.types) >= options.linear_max_size_per_stock:
+            utilization = sum(key[0] * count for key, count in bar.types.items()) / max(1, bar.width - left - right)
+            if utilization > options.linear_max_size_per_stock_threshold or any(counts[k] < demand[k] for k in bar.types):
+                return None
+        best_fit = None
+        for a, b, mirrored, reversed_ in orientation_choices[i]:
+            overlap, gap = 0, 0
+            if bar.items:
+                previous = bar.items[-1][4]
+                if options.linear_exact_angle and previous != a:
+                    continue
+                if previous * a > 0:
+                    overlap = min(abs(previous), abs(a))
+                # 锯缝沿切线法向给定，换算为型材长度方向占用。
+                gap = max(axial_kerf(previous), axial_kerf(a))
+            x = max(left, bar.end + gap - overlap)
+            finish = max(bar.end, x + widths[i])
+            remainder = bar.width - right - finish
+            real_remainder = max(0, remainder - axial_kerf(b))
+            if remainder < 0 or (check_remnant and real_remainder != 0 and real_remainder < minimum):
+                continue
+            candidate = (finish, x, a, b, mirrored, reversed_)
+            if best_fit is None or candidate < best_fit:
+                best_fit = candidate
+        return best_fit
+
+    def append(bar, i, instance, fitted):
+        finish, x, a, b, mirrored, reversed_ = fitted
+        bar.items.append((i, instance, x, a, b, mirrored, reversed_))
+        bar.end = finish
+        bar.types[keys[i]] += 1
+
+    def new_bars(i, used):
+        candidates = [j for j, s in enumerate(stocks) if available(j, used)
+                      and matches(s.material, parts[i].material)
+                      and stock_widths[j] - left - right >= widths[i]]
+        candidates.sort(key=lambda j: (not stocks[j].waste,
+                        -stock_widths[j] if options.use_large_stock_first else stock_widths[j], j))
+        result = [make_bar((j,), used) for j in candidates]
+        if not result:
+            joined = combination(i, used)
+            if joined is not None:
+                result.append(joined)
+        return result
+
+    def score(bars):
+        placed = sum(len(b.items) for b in bars)
+        stock_count = sum(len(b.components) for b in bars)
+        regular = sum(not stocks[i].waste for b in bars for i, _ in b.components)
+        patterns = (len({(b.width, tuple(sorted(b.types.items()))) for b in bars})
+                    if options.use_layout_minimization else 0)
+        cut_count = 0
+        for bar in bars:
+            count = 2 * len(bar.items) - sum(a[4] == b[3] for a, b in zip(bar.items, bar.items[1:]))
+            first, last = bar.items[0], bar.items[-1]
+            count -= not first[3] and first[2] in (0, left)
+            count -= not last[4] and last[2] + widths[last[0]] in (bar.width, bar.width - right)
+            cut_count += count + bool(left) + bool(right)
+        return (-placed, stock_count, regular,
+                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_score = candidate
+            best = [b.copy() for b in bars]
+
+    def reduce_bars():
+        """撤去一根原料，在小组内重新分配；失败时完整保留原解。"""
+        # 直端件的占用与顺序无关；斜端仍使用原来的轮廓搜索。
+        if any(a or b for a, b in offsets) or not best or -best_score[0] != requested:
+            return
+        nodes = 0
+        changed = True
+        while changed and not count_bound_reached() and not runtime.stopped(requested, attempts):
+            changed = False
+            for removed in sorted(range(len(best)), key=lambda j: best[j].end):
+                source = best[removed]
+                group = [j for j, b in enumerate(best) if b.material == source.material]
+                items = [(item[0], item[1]) for j in group for item in best[j].items]
+                # ponytail: 大组不做指数搜索；保持5000件等批量订单的原有启发式路径。
+                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]
+                needed = sum(widths[i] + kerf for i, _ in items)
+                if needed > 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)
+                counts = Counter()
+                for j, b in enumerate(best):
+                    if j not in group:
+                        counts.update(b.types)
+                seen = set()
+                local_nodes = 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 and valid_tail(b) 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)
+                        fitted = fit(bar, i, counts)
+                        if fitted is None:
+                            continue
+                        saved = bar.copy()
+                        append(bar, i, instance, fitted)
+                        counts[keys[i]] += 1
+                        if assign(position + 1):
+                            return True
+                        counts[keys[i]] -= 1
+                        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):
+                    return
+
+    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, linear=True, cancelled=runtime.cancelled, timed_out=runtime.timed_out)
+    if options.complete_mode:
+        for i, p in enumerate(parts):
+            if p.count and not any(fit(b, i, Counter(), check_remnant=False) for b in new_bars(i, Counter())):
+                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:
+            order.sort(key=lambda item: widths[item[0]])
+        elif attempt == 0:
+            order.sort(key=lambda item: widths[item[0]], reverse=True)
+        elif attempt == 1:
+            order.sort(key=lambda item: widths[item[0]])
+        else:
+            rng.shuffle(order)
+        bars, used, counts = [], Counter(), Counter()
+        for position, (i, instance) in enumerate(order):
+            if position % 32 == 0 and runtime.stopped(position, attempt + 1):
+                break
+            candidates = []
+            for j, bar in enumerate(bars):
+                fitted = fit(bar, i, counts)
+                if fitted is not None:
+                    candidates.append((not bar.waste, bar.width - right - fitted[0], j, fitted))
+            if candidates:
+                _, _, j, fitted = min(candidates)
+                append(bars[j], i, instance, fitted)
+            else:
+                for bar in new_bars(i, used):
+                    fitted = fit(bar, i, counts)
+                    if fitted is not None:
+                        append(bar, i, instance, fitted)
+                        bars.append(bar)
+                        used.update(j for j, _ in bar.components)
+                        break
+                else:
+                    continue
+            counts[keys[i]] += 1
+        remember(finish_bars(bars))
+
+    # ponytail: 指数搜索仅用于不超过 16 件的小实例；大批量沿用多次装箱启发式。
+    if len(instances) <= 16 and not options.linear_sort_ascending and not options.use_large_stock_first and not runtime.stopped():
+        order = sorted(instances, key=lambda item: widths[item[0]], reverse=True)
+        nodes = 0
+        bars, used, counts = [], Counter(), Counter()
+
+        def search(position, placed):
+            nonlocal nodes
+            nodes += 1
+            if nodes > 100000 or (nodes % 128 == 0 and runtime.stopped(placed, attempts)):
+                return
+            if best_score and placed + len(order) - position < -best_score[0]:
+                return
+            if position == len(order):
+                remember(bars)
+                return
+            i, instance = order[position]
+            visited = set()
+            for j, bar in enumerate(bars):
+                state = (bar.width, bar.material, bar.end, tuple(bar.types.items()), bar.items[-1][4])
+                if state in visited:
+                    continue
+                visited.add(state)
+                fitted = fit(bar, i, counts, check_remnant=False)
+                if fitted is None:
+                    continue
+                saved = bar.copy()
+                append(bar, i, instance, fitted)
+                counts[keys[i]] += 1
+                search(position + 1, placed + 1)
+                counts[keys[i]] -= 1
+                bars[j] = saved
+            for bar in new_bars(i, used):
+                fitted = fit(bar, i, counts, check_remnant=False)
+                if fitted is None:
+                    continue
+                append(bar, i, instance, fitted)
+                bars.append(bar)
+                used.update(j for j, _ in bar.components)
+                counts[keys[i]] += 1
+                search(position + 1, placed + 1)
+                counts[keys[i]] -= 1
+                used.subtract(j for j, _ in bar.components)
+                bars.pop()
+            search(position + 1, placed)
+
+        original_remember = remember
+        def remember(bars):
+            if all(valid_tail(b) for b in bars):
+                original_remember(bars)
+        search(0, 0)
+
+    reduce_bars()
+
+    layouts = []
+    placed_counts = Counter()
+    stock_instances = Counter()
+    for bar in best:
+        # 尾段回退可能释放整根原料；最终实例重新连续编号，不保留试排空洞。
+        actual_components = []
+        for component_i, _ in bar.components:
+            actual_components.append((component_i, stock_instances[component_i]))
+            stock_instances[component_i] += 1
+        stock_i, stock_instance = actual_components[0]
+        s = stocks[stock_i]
+        height = options.cross_section or s.height
+        placements, cut_records = [], []
+        previous_end = None
+        for local_index, (i, instance, x, a, b, mirrored, reversed_) in enumerate(bar.items):
+            p = parts[i]
+            x, a, b = x / scale, a / scale, b / scale
+            width = widths[i] / scale
+            polygon = _polygon(x, width, height, a, b) if a or b else ()
+            start_angle, end_angle = (p.angle_end, p.angle_start) if reversed_ else (p.angle_start, p.angle_end)
+            if reversed_ != mirrored:
+                start_angle = 180 - start_angle if start_angle else 0
+                end_angle = 180 - end_angle if end_angle else 0
+            placements.append(Placement(i, placed_counts[i], width, height, x, id=p.id, material=p.material,
+                                        rotated=mirrored, flipped=reversed_, angle_start=start_angle,
+                                        angle_end=end_angle, polygon=polygon))
+            placed_counts[i] += 1
+            for is_start, top, bottom, angle in ((True, x + max(a, 0), x + max(-a, 0), start_angle),
+                                                (False, x + width + min(b, 0), x + width - max(b, 0), end_angle)):
+                if abs(top) < 1e-9 and abs(bottom) < 1e-9 or abs(top - bar.width / scale) < 1e-9 and abs(bottom - bar.width / scale) < 1e-9:
+                    continue
+                if is_start and local_index == 0 and not a and abs(top - left / scale) < 1e-9 and left:
+                    continue
+                if not is_start and not b and abs(top - (bar.width - right) / scale) < 1e-9 and right:
+                    continue
+                offset = a if is_start else b
+                allowance = kerf / scale * hypot(height, offset) / (2 * height)
+                shift = -allowance if is_start else allowance
+                cut = Cut(top + shift, 0, bottom + shift, height, angle=angle or 90,
+                          part_indices=(local_index,))
+                if (is_start and previous_end is not None
+                        and abs(cut_records[previous_end].x1 - cut.x1) <= 1e-9
+                        and abs(cut_records[previous_end].x2 - cut.x2) <= 1e-9):
+                    # 相同斜端的一次共切，中心位于两条成品边之间，合并关联的局部零件索引。
+                    old = cut_records[previous_end]
+                    cut_records[previous_end] = replace(old, x1=(old.x1 + cut.x1) / 2,
+                                                       x2=(old.x2 + cut.x2) / 2,
+                                                       part_indices=old.part_indices + (local_index,))
+                else:
+                    cut_records.append(cut)
+                    if not is_start:
+                        previous_end = len(cut_records) - 1
+        remnants = ()
+        remnant_x, remnant_width = tail(bar)
+        if remnant_width > 0 and remnant_width >= minimum:
+            remnants = (Remnant(remnant_width / scale, height, remnant_x / scale, material=bar.material),)
+        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)
+        components = tuple(StockComponent(i, instance, stock_widths[i] / scale, stocks[i].id,
+                                         stocks[i].waste, stocks[i].material) for i, instance in actual_components)
+        layouts.append(Layout(stock_i, stock_instance, bar.width / scale, height,
+                              ";".join(stocks[i].id for i, _ in bar.components), bar.material,
+                              bar.waste, tuple(placements), remnants, tuple(cut_records), trim_cuts, components))
+    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)