笔画排序算法规格书 v1.0

1. cv2.connectedComponentsWithStats(mask, connectivity=8)
2. 每个连通域算 area / bbox / stroke_ratio = area / bbox周长
3. 分类：stroke_ratio < 8.0 → "描边线"；否则 → "色块"
4. area < 60 px² 丢弃（噪点）
5. 合并：cv2.dilate(5×5, iters=2) 后重新连通域，
   膨胀后同属一域的原始单元合并为一个"单元组"
   —— 防止一条被小色块打断的轮廓线被拆成两个不相关单元

score(u) = 0.45 * norm_area(u)              # 面积：先大后小
         + 0.25 * (1 - norm_top_y(u))       # 位置：偏上优先
         + 0.30 * (1 - norm_dist_to_last(u))# 就近：离上一笔越近越优先 ← 关键项
         + 0.00 * norm_zorder(u)            # 图层信息（暂无，权重 0）

# 贪心流程
first = 面积最大的单元            # 呼应实测"首个 path 复杂度最高"
while 还有剩余:
    candidates = 按到上一笔质心的距离排序的前 K=5 个
    next = candidates 中 score 最大者

skel = skeletonize(unit.mask)
graph = sknw.build_sknw(skel, multi=True)
起点 = 离"上一笔收笔点"最近的端点（度=1）；无端点（闭环）则就近切开
DFS，岔路口打分：

score = 1.0 * cos_sim(当前运笔方向, 候选边起始方向)   # 方向连续性，主导项
      + 0.6 * (-1 if 该边已画过 else 0)              # 未画过的优先，但不绝对禁止重走
      + 0.2 * min(边长, 200) / 200                   # 先长后短，仅作 tie-break

while 还有像素:
    取最外层轮廓 (cv2.findContours, RETR_EXTERNAL)
    向内腐蚀一个笔刷半径 (disk(12))
各层轮廓按外→内顺序，层内用之字形连接
面积 < 400 px² 的小色块跳过分层，直接一笔带过/淡入

raw_duration(u) = 0.4 + (点数占比) × (总时长 - N×0.4 - (N-1)×0.15)
笔画之间插入 0.15s 抬笔停顿
整体缩放命中总时长，但 0.4s 是不可压缩下限（优先压长笔画的富余）
每笔首尾各 3 帧 ease-in-out，模拟起笔/收笔的物理感

"""whiteboard_stroke_order.py —— 笔画排序主流程"""
import cv2, numpy as np, networkx as nx, sknw
from skimage.morphology import skeletonize
from dataclasses import dataclass, field

@dataclass
class Unit:
    id: int; mask: np.ndarray; bbox: tuple; area: int
    centroid: np.ndarray; kind: str            # "stroke" | "block"
    sub_branches: list = field(default_factory=list)

@dataclass
class Stroke:
    unit_id: int; points: np.ndarray           # (N,2) 有序坐标
    start_time: float; end_time: float
    kind: str                                  # "stroke" | "block_fill"

def compute_stroke_order(binary_mask, cfg=Config()) -> list[Stroke]:
    units = segment_units(binary_mask, cfg)            # 层级1
    ordered = order_units(units, binary_mask.shape, cfg)  # 层级2
    paths, entry = {}, np.array([binary_mask.shape[1]/2, 0])
    for u in ordered:                                   # 层级3
        paths[u.id] = (trace_stroke_unit(u, entry, cfg) if u.kind == "stroke"
                       else trace_block_unit(u, cfg))
        if len(paths[u.id]): entry = paths[u.id][-1]
    return assign_timing(ordered, paths, cfg)           # 层级4

def order_units(units, shape, cfg):
    h, w = shape[:2]; diag = np.hypot(h, w)
    max_area = max(u.area for u in units); by_id = {u.id: u for u in units}
    bg = [u for u in units if u.bbox[2]*u.bbox[3] > 0.7*h*w]
    first = max(bg or units, key=lambda u: u.area)
    ordered, remaining = [first], {u.id for u in units} - {first.id}
    while remaining:
        last = ordered[-1]
        cands = sorted(remaining,
            key=lambda i: np.linalg.norm(by_id[i].centroid - last.centroid))[:cfg.candidate_pool_k]
        nxt = max(cands, key=lambda i: score_unit(by_id[i], last, diag, max_area, h, cfg))
        ordered.append(by_id[nxt]); remaining.remove(nxt)
    return ordered

def dfs_with_direction_heuristic(graph, start, cfg):
    visited, path, cur = set(), [], start
    incoming = np.array([0.0, 1.0])
    for _ in range(graph.number_of_edges() * 3):
        edges = list(graph.edges(cur, keys=True, data=True))
        if not edges: break
        best, best_s = None, -1e9
        for u, v, k, d in edges:
            eid = (min(u, v), max(u, v), k); pts = d['pts']
            cand = normalize(pts[min(5, len(pts)-1)] - pts[0])
            s = (cfg.w_dir * float(np.dot(incoming, cand))
                 + cfg.w_visited * (-1.0 if eid in visited else 0.0)
                 + cfg.w_length * min(d.get('weight', 0), cfg.long_edge_cap) / cfg.long_edge_cap)
            if s > best_s: best_s, best = s, (u, v, k, d)
        u, v, k, d = best; visited.add((min(u,v), max(u,v), k))
        pts = d['pts'] if u == cur else d['pts'][::-1]
        path.append(pts); incoming = normalize(pts[-1] - pts[max(0, len(pts)-6)])
        cur = v if u == cur else u
        if len(visited) >= graph.number_of_edges(): break
    return np.concatenate(path) if path else np.empty((0, 2))