dsh-courseware 0.1.0

package/engine/pptxgen/profile.py

@@ -0,0 +1,456 @@
+"""样式档案：从模板自带的示例幻灯片里学习"页面骨架"。
+
+很多真实模板并不靠版式（layout）来定义观感，而是把设计语言重复地画在每一页上——
+比如"左上角模块标签 + 圆角矩形标题条 + 中间内容区"。
+把这种规律自动学出来，新生成的页面才能和模板自己做的页面长得一样。
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from pptx.oxml.ns import qn
+
+from .template import TemplateInfo
+from .util import parse_color
+
+Box = Tuple[int, int, int, int]
+
+
+@dataclass
+class TextStyle:
+    size_pt: Optional[float] = None
+    bold: Optional[bool] = None
+    italic: Optional[bool] = None
+    font: Optional[str] = None
+    color: Optional[str] = None
+    align: Optional[str] = None
+    anchor: Optional[str] = None
+
+
+@dataclass
+class Skeleton:
+    """一个可复用的页面骨架元素。"""
+
+    box: Box
+    style: TextStyle
+    fill: Optional[str] = None
+    fill_alpha: float = 1.0
+    line: Optional[str] = None
+    line_width_pt: float = 1.0
+    radius: float = 0.15
+    occurrences: int = 0
+
+
+@dataclass
+class StyleProfile:
+    module_label: Optional[Skeleton] = None     # 左上角模块标签（文本框）
+    title_chip: Optional[Skeleton] = None       # 标题条（圆角矩形）
+    cover_title_box: Optional[Box] = None
+    end_title_box: Optional[Box] = None
+    content_title_box: Optional[Box] = None
+    content_box: Optional[Box] = None
+    # 正文字体/字号也从样张学——主题里的中文字体经常和实际用的不一样
+    body_font: Optional[str] = None
+    body_size_pt: Optional[float] = None
+    body_color: Optional[str] = None
+    body_line_spacing: float = 1.30
+    slide_w: int = 0
+    slide_h: int = 0
+    notes: List[str] = field(default_factory=list)
+
+    @property
+    def has_chip_layout(self) -> bool:
+        return self.title_chip is not None
+
+    def content_area(self) -> Box:
+        if self.content_box:
+            return self.content_box
+        return (int(self.slide_w * 0.10), int(self.slide_h * 0.24),
+                int(self.slide_w * 0.82), int(self.slide_h * 0.66))
+
+
+# --------------------------------------------------------------------------
+def learn_profile(tpl: TemplateInfo, *, min_occurrences: int = 3) -> Optional[StyleProfile]:
+    prs = tpl._prs
+    if prs is None:
+        return None
+    slides = list(prs.slides)
+    if len(slides) < 3:
+        return None
+
+    W, H = tpl.width, tpl.height
+    theme = dict(tpl.theme_colors)
+    prof = StyleProfile(slide_w=W, slide_h=H)
+
+    label_votes: Counter = Counter()
+    label_repr: Dict[tuple, Skeleton] = {}
+    chip_votes: Counter = Counter()
+    chip_repr: Dict[tuple, Skeleton] = {}
+    chip_xs: List[int] = []
+    content_titles: List[Box] = []
+    cover_boxes: List[Box] = []
+    end_boxes: List[Box] = []
+    below_chip_tops: List[float] = []
+    body_runs: Counter = Counter()          # (字体, 字号) 组合
+    body_font_votes: Counter = Counter()    # 只按字体
+    body_size_votes: Counter = Counter()    # 只按显式写出的字号
+    body_repr: Dict[tuple, TextStyle] = {}
+
+    for idx, slide in enumerate(slides):
+        is_first = idx == 0
+        is_last = idx == len(slides) - 1
+        shape_list = [sh for sh in slide.shapes if sh.width and sh.height]
+
+        # 封面 / 结束页：整页几乎只有一个带文字的标题
+        texty = [sh for sh in shape_list
+                 if sh.has_text_frame and sh.text_frame.text.strip()]
+        if (is_first or is_last) and len(texty) <= 2 and len(shape_list) <= 4:
+            for sh in texty:
+                if sh.is_placeholder:
+                    box = (int(sh.left), int(sh.top), int(sh.width), int(sh.height))
+                    (cover_boxes if is_first else end_boxes).append(box)
+            continue
+
+        non_ph_texts = 0
+        title_box = None
+        for sh in shape_list:
+            x, y = int(sh.left or 0), int(sh.top or 0)
+            w, h = int(sh.width or 0), int(sh.height or 0)
+
+            if sh.is_placeholder:
+                try:
+                    ptype = sh.placeholder_format.type
+                except Exception:
+                    ptype = None
+                is_title = ptype in (13, 1, 3) or (sh.placeholder_format.idx == 0)
+                if is_title and y < H * 0.5 and w < W * 0.95:
+                    content_titles.append((x, y, w, h))
+                    title_box = (x, y, w, h)
+                continue
+
+            if not sh.has_text_frame or not sh.text_frame.text.strip():
+                continue
+            non_ph_texts += 1
+
+            # --- 左上角模块标签：小文本框，贴在页面左上 ---
+            if w < W * 0.24 and x < W * 0.06 and y < H * 0.17 and h < H * 0.13:
+                key = (_r(x / W), _r(y / H), _r(w / W), _r(h / H))
+                label_votes[key] += 1
+                if key not in label_repr:
+                    label_repr[key] = Skeleton(box=(x, y, w, h),
+                                               style=_text_style(sh, theme),
+                                               fill=None)
+                continue
+
+            # --- 标题条：顶部圆角矩形 ---
+            if _prst(sh) == "roundRect" and y < H * 0.13 and h < H * 0.18 and w < W * 0.72:
+                key = (_r(y / H), _r(h / H))
+                chip_votes[key] += 1
+                chip_xs.append(x)
+                if key not in chip_repr:
+                    sk = Skeleton(box=(x, y, w, h), style=_text_style(sh, theme),
+                                  radius=_radius(sh))
+                    _read_fill(sh, sk, theme)
+                    chip_repr[key] = sk
+
+        # --- 正文排版：非占位符、且不是模块标签/标题条的文字 ---
+        for sh in shape_list:
+            if sh.is_placeholder or not sh.has_text_frame or not sh.text_frame.text.strip():
+                continue
+            bx, by = int(sh.left or 0), int(sh.top or 0)
+            bw, bh = int(sh.width or 0), int(sh.height or 0)
+            if bw < W * 0.24 and bx < W * 0.06 and by < H * 0.17 and bh < H * 0.13:
+                continue                                    # 模块标签
+            if _prst(sh) == "roundRect" and by < H * 0.13 and bh < H * 0.18:
+                continue                                    # 标题条
+            for para in sh.text_frame.paragraphs:
+                for run in para.runs:
+                    if not run.text.strip():
+                        continue
+                    n = len(run.text)
+                    size = round(run.font.size.pt) if run.font.size else None
+                    key = (run.font.name, size)
+                    body_runs[key] += n
+                    body_repr.setdefault(key, _text_style(sh, theme))
+                    if run.font.name:
+                        body_font_votes[run.font.name] += n
+                    if size:
+                        body_size_votes[size] += n
+
+        # 内容区上边界：标题条之下第一块内容
+        if title_box is None and non_ph_texts:
+            tops = [sh.top / H for sh in slide.shapes
+                    if sh.top and not sh.is_placeholder and sh.width and sh.height
+                    and sh.top / H > 0.15]
+            if tops:
+                below_chip_tops.append(min(tops))
+
+    # --- 结论 ---
+    if label_votes:
+        key, n = label_votes.most_common(1)[0]
+        if n >= min_occurrences:
+            sk = label_repr[key]
+            sk.occurrences = n
+            prof.module_label = sk
+            prof.notes.append(f"学到模块标签：{n} 页重复 @ {_fmt(sk.box, W, H)}")
+
+    if chip_votes:
+        key, n = chip_votes.most_common(1)[0]
+        if n >= min_occurrences:
+            sk = chip_repr[key]
+            sk.occurrences = n
+            # 用观测到的最小 x 和最常见高度
+            sk.box = (min(chip_xs), sk.box[1], sk.box[2], sk.box[3])
+            prof.title_chip = sk
+            prof.notes.append(f"学到标题条：{n} 页重复 @ y={sk.box[1]/H:.3f} h={sk.box[3]/H:.3f}")
+
+    if body_font_votes or body_size_votes:
+        bfont = body_font_votes.most_common(1)[0][0] if body_font_votes else None
+        bsize = body_size_votes.most_common(1)[0][0] if body_size_votes else None
+        prof.body_font = bfont
+        prof.body_size_pt = float(bsize) if bsize else None
+        st = body_repr.get((bfont, bsize))
+        if st is not None and st.color:
+            prof.body_color = st.color
+        prof.notes.append(f"学到正文排版：{bfont} {bsize}pt")
+
+    if content_titles:
+        prof.content_title_box = _median_box(content_titles)
+
+    if cover_boxes:
+        prof.cover_title_box = _median_box(cover_boxes)
+    if end_boxes:
+        prof.end_title_box = _median_box(end_boxes)
+
+    # 内容区：标题条下方 -> 画布 92%
+    if prof.title_chip:
+        cx, cy, _cw, ch = prof.title_chip.box
+        gap = int(H * 0.030)
+        top = cy + ch + gap
+        prof.content_box = (cx, top, int(W * 0.93) - cx, int(H * 0.90) - top)
+    elif below_chip_tops:
+        top = int(min(below_chip_tops) * H)
+        prof.content_box = (int(W * 0.10), top, int(W * 0.82), int(H * 0.92) - top)
+
+    if not (prof.module_label or prof.title_chip):
+        return None
+    return prof
+
+
+# --------------------------------------------------------------------------
+# 辅助
+# --------------------------------------------------------------------------
+def _r(v: float, tol: float = 0.025) -> float:
+    return round(v / tol) * tol
+
+
+def _prst(shape) -> Optional[str]:
+    try:
+        geom = shape._element.spPr.find(qn("a:prstGeom"))
+        return geom.get("prst") if geom is not None else None
+    except Exception:
+        return None
+
+
+def _radius(shape) -> float:
+    try:
+        gd = shape._element.spPr.find(qn("a:prstGeom")).find(".//" + qn("a:gd"))
+        if gd is not None and gd.get("fmla"):
+            return int(gd.get("fmla").split()[-1]) / 100000.0
+    except Exception:
+        pass
+    try:
+        return float(shape.adjustments[0])
+    except Exception:
+        return 0.15
+
+
+def _scheme_to_hex(val: str, theme: Dict[str, str]) -> Optional[str]:
+    if not val:
+        return None
+    key = val
+    alias = {
+        "background1": "bg1", "background2": "bg2",
+        "text1": "tx1", "text2": "tx2",
+        "dk1": "dk1", "lt1": "lt1", "dk2": "dk2", "lt2": "lt2",
+        "hyperlink": "hlink", "followedhyperlink": "folHlink",
+    }
+    key = alias.get(val.lower(), val)
+    return theme.get(key)
+
+
+def _color_of(node, theme: Dict[str, str]) -> Optional[str]:
+    """从含 srgbClr / schemeClr / sysClr 的节点解析出 #RRGGBB（含 lumMod/lumOff/tint/shade）。"""
+    if node is None:
+        return None
+    color_el = None
+    base = None
+    for tag, key in (("a:srgbClr", "val"), ("a:schemeClr", "val"), ("a:sysClr", "lastClr")):
+        el = node.find(qn(tag))
+        if el is not None:
+            color_el = el
+            v = el.get(key)
+            base = _scheme_to_hex(v, theme) if tag == "a:schemeClr" else ((v or "").upper() or None)
+            break
+    if not base:
+        return None
+    return _apply_color_mods(base, color_el)
+
+
+def _apply_color_mods(hex_color: str, el) -> str:
+    """按 OOXML 修饰符调整颜色：lumMod/lumOff（亮度偏移）、tint（提亮）、shade（压暗）。"""
+    r, g, b = [int(hex_color[i:i + 2], 16) for i in (0, 2, 4)]
+    mods: Dict[str, float] = {}
+    for child in el:
+        tag = child.tag.split("}")[-1]
+        v = child.get("val")
+        if v:
+            try:
+                mods[tag] = int(v) / 100000.0
+            except ValueError:
+                pass
+    lum = mods.get("lumMod", 1.0)
+    off = mods.get("lumOff", 0.0)
+    if lum != 1.0 or off:
+        r = max(0, min(255, int(round(r * lum + 255 * off))))
+        g = max(0, min(255, int(round(g * lum + 255 * off))))
+        b = max(0, min(255, int(round(b * lum + 255 * off))))
+    elif "tint" in mods:
+        t = mods["tint"]
+        r = int(round(r + (255 - r) * t))
+        g = int(round(g + (255 - g) * t))
+        b = int(round(b + (255 - b) * t))
+    elif "shade" in mods:
+        t = mods["shade"]
+        r = int(round(r * (1 - t)))
+        g = int(round(g * (1 - t)))
+        b = int(round(b * (1 - t)))
+    return f"{r:02X}{g:02X}{b:02X}"
+
+
+def _resolve_run_color(shape, theme: Dict[str, str]) -> Optional[str]:
+    """取文本框里第一个带 solidFill 的 run 颜色（支持主题色与修饰），解析失败返回 None。"""
+    try:
+        txBody = shape.text_frame._txBody
+    except Exception:
+        return None
+    for rPr in txBody.iter(qn("a:rPr")):
+        solid = rPr.find(qn("a:solidFill"))
+        if solid is None:
+            continue
+        c = _color_of(solid, theme)
+        if c:
+            return c
+    return None
+
+
+def _read_fill(shape, sk: Skeleton, theme: Dict[str, str]) -> None:
+    try:
+        spPr = shape._element.spPr
+    except Exception:
+        return
+    solid = spPr.find(qn("a:solidFill"))
+    if solid is not None:
+        sk.fill = _color_of(solid, theme)
+        alpha = solid.find(".//" + qn("a:alpha"))
+        if alpha is not None and alpha.get("val"):
+            sk.fill_alpha = int(alpha.get("val")) / 100000.0
+    ln = spPr.find(qn("a:ln"))
+    if ln is not None:
+        lnfill = ln.find(qn("a:solidFill"))
+        if lnfill is not None:
+            sk.line = _color_of(lnfill, theme)
+        w = ln.get("w")
+        if w:
+            sk.line_width_pt = int(w) / 12700.0
+    if sk.fill is None:
+        try:
+            fill = shape.fill
+            if str(fill.type).startswith("SOLID"):
+                sk.fill = parse_color(str(fill.fore_color.rgb))
+        except Exception:
+            pass
+
+
+def _text_style(shape, theme: Optional[Dict[str, str]] = None) -> TextStyle:
+    ts = TextStyle()
+    try:
+        tf = shape.text_frame
+        ts.anchor = str(tf.vertical_anchor).split(" ")[0].split(".")[-1].lower() if tf.vertical_anchor else None
+    except Exception:
+        pass
+    try:
+        for p in shape.text_frame.paragraphs:
+            if ts.align is None and p.alignment is not None:
+                ts.align = str(p.alignment).split(" ")[0].split(".")[-1].lower()
+            for r in p.runs:
+                f = r.font
+                if f.size is not None and ts.size_pt is None:
+                    ts.size_pt = f.size.pt
+                if f.bold is not None and ts.bold is None:
+                    ts.bold = f.bold
+                if f.italic is not None and ts.italic is None:
+                    ts.italic = f.italic
+                if f.name and ts.font is None:
+                    ts.font = f.name
+                if ts.color is None:
+                    try:
+                        ts.color = parse_color(str(f.color.rgb))
+                    except Exception:
+                        pass
+            if ts.size_pt and ts.font:
+                break
+    except Exception:
+        pass
+    # 主题色（schemeClr）python-pptx 读不出 RGB，直接回 XML 里解析，并应用 lumMod 等修饰
+    if ts.color is None and theme:
+        ts.color = _resolve_run_color(shape, theme)
+    return ts
+
+
+def _median_box(boxes: List[Box]) -> Box:
+    import statistics as st
+
+    return (
+        int(st.median(b[0] for b in boxes)),
+        int(st.median(b[1] for b in boxes)),
+        int(st.median(b[2] for b in boxes)),
+        int(st.median(b[3] for b in boxes)),
+    )
+
+
+def _fmt(box: Box, W: int, H: int) -> str:
+    return f"({box[0]/W:.2f},{box[1]/H:.2f},{box[2]/W:.2f},{box[3]/H:.2f})"
+
+
+def describe(prof: Optional[StyleProfile]) -> str:
+    if prof is None:
+        return "样式档案：未学到（模板可能主要依赖版式，将按版式渲染）"
+    lines = ["样式档案（从模板示例页学到）"]
+    if prof.module_label:
+        sk = prof.module_label
+        color = f" 文字色=#{sk.style.color}" if sk.style.color else ""
+        lines.append(
+            f"  模块标签 : {_fmt(sk.box, prof.slide_w, prof.slide_h)} "
+            f"{sk.style.size_pt}pt {sk.style.font} 对齐={sk.style.align}{color} 出现 {sk.occurrences} 次"
+        )
+    if prof.title_chip:
+        sk = prof.title_chip
+        color = f" 文字色=#{sk.style.color}" if sk.style.color else ""
+        lines.append(
+            f"  标题条   : x={sk.box[0]/prof.slide_w:.3f} y={sk.box[1]/prof.slide_h:.3f} "
+            f"h={sk.box[3]/prof.slide_h:.3f} 填充=#{sk.fill} 描边=#{sk.line} "
+            f"{sk.style.size_pt}pt {sk.style.font}{color} 出现 {sk.occurrences} 次"
+        )
+    if prof.content_box:
+        lines.append(f"  内容区   : {_fmt(prof.content_box, prof.slide_w, prof.slide_h)}")
+    if prof.body_font or prof.body_size_pt:
+        lines.append(f"  正文排版 : {prof.body_font} {prof.body_size_pt}pt")
+    if prof.cover_title_box:
+        lines.append(f"  封面标题 : {_fmt(prof.cover_title_box, prof.slide_w, prof.slide_h)}")
+    if prof.end_title_box:
+        lines.append(f"  结束页标题: {_fmt(prof.end_title_box, prof.slide_w, prof.slide_h)}")
+    return "\n".join(lines)