# -*- coding: utf-8 -*-
"""
生成「物理模块 + 神经网络层 深度耦合」架构图的可编辑 PPT 素材。
每个子元素单独一页，文字均为可编辑文本框；另含一页完整拼装参考。

运行: python generate_physics_nn_diagram.py
"""
from __future__ import annotations

import math
import random
from pathlib import Path

from pptx import Presentation
from pptx.dml.color import RGBColor
from pptx.enum.dml import MSO_LINE_DASH_STYLE
from pptx.enum.shapes import MSO_CONNECTOR, MSO_SHAPE
from pptx.enum.text import MSO_ANCHOR, PP_ALIGN
from pptx.util import Inches, Pt

OUT_DIR = Path(__file__).resolve().parent
OUT_PPTX = OUT_DIR / "物理神经网络耦合图_可编辑素材.pptx"

# 配色（贴近原图）
C_BG = RGBColor(0x0A, 0x0A, 0x0A)
C_WHITE = RGBColor(0xFF, 0xFF, 0xFF)
C_BLACK = RGBColor(0x00, 0x00, 0x00)
C_BLUE = RGBColor(0x4A, 0x86, 0xC8)
C_BLUE_LT = RGBColor(0x6D, 0xA3, 0xE8)
C_TEAL = RGBColor(0x3D, 0xA8, 0x9A)
C_GREY = RGBColor(0xB0, 0xB0, 0xB0)
C_GREY_DK = RGBColor(0x55, 0x55, 0x55)
C_GREY_LT = RGBColor(0xD9, 0xD9, 0xD9)
C_LINE = RGBColor(0x88, 0x88, 0x88)

FONT = "Microsoft YaHei"
SLIDE_W = Inches(13.333)
SLIDE_H = Inches(7.5)


def new_prs() -> Presentation:
    prs = Presentation()
    prs.slide_width = SLIDE_W
    prs.slide_height = SLIDE_H
    return prs


def blank_slide(prs: Presentation, dark: bool = False):
    slide = prs.slides.add_slide(prs.slide_layouts[6])
    if dark:
        fill = slide.background.fill
        fill.solid()
        fill.fore_color.rgb = C_BG
    return slide


def add_label(slide, left, top, width, height, text, size=14, bold=False,
              color=C_BLACK, align=PP_ALIGN.CENTER, wrap=True):
    box = slide.shapes.add_textbox(left, top, width, height)
    tf = box.text_frame
    tf.word_wrap = wrap
    tf.vertical_anchor = MSO_ANCHOR.MIDDLE
    p = tf.paragraphs[0]
    p.text = text
    p.alignment = align
    p.font.name = FONT
    p.font.size = Pt(size)
    p.font.bold = bold
    p.font.color.rgb = color
    return box


def add_round_box(slide, left, top, width, height, fill=C_WHITE, line=C_BLACK,
                  line_w=1.0, radius_hint=0.08):
    shape = slide.shapes.add_shape(
        MSO_SHAPE.ROUNDED_RECTANGLE, left, top, width, height
    )
    shape.fill.solid()
    shape.fill.fore_color.rgb = fill
    shape.line.color.rgb = line
    shape.line.width = Pt(line_w)
    # 圆角
    if hasattr(shape, "adjustments") and shape.adjustments:
        shape.adjustments[0] = radius_hint
    return shape


def add_oval(slide, left, top, size, fill, line=None, line_w=1.0):
    shape = slide.shapes.add_shape(MSO_SHAPE.OVAL, left, top, size, size)
    shape.fill.solid()
    shape.fill.fore_color.rgb = fill
    if line:
        shape.line.color.rgb = line
        shape.line.width = Pt(line_w)
    else:
        shape.line.fill.background()
    return shape


def add_line(slide, x1, y1, x2, y2, color=C_LINE, width=0.75, dash=None):
    conn = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, x1, y1, x2, y2)
    conn.line.color.rgb = color
    conn.line.width = Pt(width)
    if dash:
        conn.line.dash_style = dash
    return conn


def add_arrow_down(slide, cx, y1, y2, color=C_WHITE, dash=False):
    add_line(slide, cx, y1, cx, y2 - Inches(0.08), color, 1.2,
             MSO_LINE_DASH_STYLE.DASH if dash else None)
    tri = slide.shapes.add_shape(
        MSO_SHAPE.ISOSCELES_TRIANGLE,
        cx - Inches(0.06), y2 - Inches(0.12), Inches(0.12), Inches(0.12)
    )
    tri.rotation = 180
    tri.fill.solid()
    tri.fill.fore_color.rgb = color
    tri.line.fill.background()
    return tri


def add_arrow_up(slide, cx, y1, y2, color=C_WHITE):
    add_line(slide, cx, y1 + Inches(0.08), cx, y2, color, 1.2)
    tri = slide.shapes.add_shape(
        MSO_SHAPE.ISOSCELES_TRIANGLE,
        cx - Inches(0.06), y1, Inches(0.12), Inches(0.12)
    )
    tri.fill.solid()
    tri.fill.fore_color.rgb = color
    tri.line.fill.background()


def add_arrow_right(slide, x1, y, x2, color=C_WHITE):
    add_line(slide, x1, y, x2 - Inches(0.08), y, color, 1.5)
    tri = slide.shapes.add_shape(
        MSO_SHAPE.ISOSCELES_TRIANGLE,
        x2 - Inches(0.12), y - Inches(0.06), Inches(0.12), Inches(0.12)
    )
    tri.rotation = 90
    tri.fill.solid()
    tri.fill.fore_color.rgb = color
    tri.line.fill.background()


def add_double_arrow_h(slide, x1, y1, x2, y2=None, color=C_WHITE):
    if y2 is None:
        y2 = y1
    add_line(slide, x1 + Inches(0.1), y1, x2 - Inches(0.1), y2, color, 1.5)
    for x, rot in ((x1, 270), (x2 - Inches(0.12), 90)):
        tri = slide.shapes.add_shape(
            MSO_SHAPE.ISOSCELES_TRIANGLE,
            x, y1 - Inches(0.06), Inches(0.12), Inches(0.12)
        )
        tri.rotation = rot
        tri.fill.solid()
        tri.fill.fore_color.rgb = color
        tri.line.fill.background()


def draw_mesh_icon(slide, cx, cy, w, h, color=C_GREY):
    """简化 3D 网格图标"""
    pts = [
        (cx - w * 0.35, cy + h * 0.2),
        (cx, cy - h * 0.35),
        (cx + w * 0.35, cy + h * 0.2),
        (cx, cy + h * 0.35),
    ]
    for i in range(4):
        x1, y1 = pts[i]
        x2, y2 = pts[(i + 1) % 4]
        add_line(slide, x1, y1, x2, y2, color, 1.0)
    add_line(slide, pts[0][0], pts[0][1], pts[2][0], pts[2][1], color, 0.8)
    add_line(slide, pts[1][0], pts[1][1], pts[3][0], pts[3][1], color, 0.8)
    for i in range(3):
        t = (i + 1) / 4
        mx = pts[0][0] + t * (pts[2][0] - pts[0][0])
        my = pts[0][1] + t * (pts[2][1] - pts[0][1])
        add_line(slide, mx, my, pts[1][0], pts[1][1], color, 0.6)


def draw_radar_icon(slide, cx, cy, size, color=C_GREY):
    base = slide.shapes.add_shape(
        MSO_SHAPE.OVAL, cx - size * 0.15, cy + size * 0.05,
        size * 0.3, size * 0.15
    )
    base.fill.solid()
    base.fill.fore_color.rgb = color
    base.line.fill.background()
    dish = slide.shapes.add_shape(
        MSO_SHAPE.OVAL, cx - size * 0.35, cy - size * 0.25,
        size * 0.7, size * 0.35
    )
    dish.fill.background()
    dish.line.color.rgb = color
    dish.line.width = Pt(1.2)
    for ang in (-25, 0, 25):
        rad = math.radians(ang - 90)
        add_line(
            slide, cx, cy,
            cx + math.cos(rad) * size * 0.55,
            cy + math.sin(rad) * size * 0.55,
            color, 0.8, MSO_LINE_DASH_STYLE.DASH
        )


def draw_field_icon(slide, cx, cy, w, h, color=C_GREY):
    rect = slide.shapes.add_shape(
        MSO_SHAPE.RECTANGLE, cx - w / 2, cy - h / 2, w, h
    )
    rect.fill.background()
    rect.line.color.rgb = color
    rect.line.width = Pt(1.0)
    for i in range(4):
        y = cy - h / 2 + h * (i + 1) / 5
        add_line(slide, cx - w / 2, y, cx + w / 2, y, color, 0.5)
    for i in range(4):
        x = cx - w / 2 + w * (i + 1) / 5
        add_line(slide, x, cy - h / 2, x, cy + h / 2, color, 0.5)
    peak = add_oval(slide, cx - Inches(0.08), cy - Inches(0.08), Inches(0.16), C_GREY_DK)


def draw_wave_icon(slide, cx, cy, w, color=C_GREY):
    for i, phase in enumerate((0, 0.4, 0.8)):
        pts = []
        steps = 20
        for s in range(steps + 1):
            t = s / steps
            x = cx - w / 2 + w * t
            y = cy + math.sin(t * math.pi * 2 + phase) * Inches(0.12)
            pts.append((x, y))
        for j in range(len(pts) - 1):
            add_line(slide, pts[j][0], pts[j][1], pts[j + 1][0], pts[j + 1][1],
                     color, 1.0 if i == 1 else 0.7)


def draw_beam_icon(slide, cx, cy, size, color=C_GREY):
    add_line(slide, cx - size * 0.3, cy, cx, cy, color, 1.2)
    for ang in (-35, -15, 15, 35):
        rad = math.radians(ang)
        add_line(slide, cx, cy, cx + math.cos(rad) * size * 0.45,
                 cy + math.sin(rad) * size * 0.45, color, 1.0)


def draw_boundary_icon(slide, cx, cy, size, color=C_GREY):
    add_line(slide, cx, cy - size * 0.35, cx, cy + size * 0.35, color, 1.2,
             MSO_LINE_DASH_STYLE.DASH)
    add_line(slide, cx - size * 0.35, cy, cx + size * 0.1, cy - size * 0.15, color, 1.2)
    tri = slide.shapes.add_shape(
        MSO_SHAPE.ISOSCELES_TRIANGLE,
        cx + size * 0.05, cy - size * 0.22, Inches(0.1), Inches(0.1)
    )
    tri.rotation = 120
    tri.fill.solid()
    tri.fill.fore_color.rgb = color
    tri.line.fill.background()


def draw_scale_icon(slide, cx, cy, w, color=C_GREY):
    add_line(slide, cx, cy + Inches(0.15), cx, cy - Inches(0.25), color, 1.5)
    add_line(slide, cx - w / 2, cy - Inches(0.25), cx + w / 2, cy - Inches(0.25), color, 1.5)
    for dx in (-w / 2, w / 2):
        pan = slide.shapes.add_shape(
            MSO_SHAPE.OVAL, cx + dx - Inches(0.12), cy - Inches(0.05),
            Inches(0.24), Inches(0.12)
        )
        pan.fill.background()
        pan.line.color.rgb = color
        pan.line.width = Pt(1.0)


def slide_title_bar(slide, title: str):
    add_label(slide, Inches(0.4), Inches(0.15), Inches(12.5), Inches(0.45),
              title, size=18, bold=True, color=C_GREY_DK, align=PP_ALIGN.LEFT)


# ---------- 各子元素 ----------

def make_top_box_1(slide):
    slide_title_bar(slide, "01 · 顶部算子框 — 连续方程算子")
    w, h = Inches(2.6), Inches(1.35)
    x, y = Inches(5.4), Inches(2.8)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.08), w, Inches(0.4),
              "连续方程算子", size=16, bold=True)
    add_label(slide, x, y + Inches(0.45), w, Inches(0.75),
              "∇·(ρv) + ∂ρ/∂t = 0", size=13, color=C_GREY_DK)
    add_arrow_down(slide, x + w / 2, y + h, y + h + Inches(0.55), dash=True)


def make_top_box_2(slide):
    slide_title_bar(slide, "02 · 顶部算子框 — 边界条件")
    w, h = Inches(2.6), Inches(1.35)
    x, y = Inches(5.4), Inches(2.8)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.08), w, Inches(0.4),
              "边界条件", size=16, bold=True)
    add_label(slide, x, y + Inches(0.45), w, Inches(0.75),
              "B(u) = g  或  n×E = 0", size=13, color=C_GREY_DK)
    add_arrow_down(slide, x + w / 2, y + h, y + h + Inches(0.55), dash=True)


def make_top_box_3(slide):
    slide_title_bar(slide, "03 · 顶部算子框 — 传播/散射算子")
    w, h = Inches(2.6), Inches(1.35)
    x, y = Inches(5.4), Inches(2.8)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.08), w, Inches(0.4),
              "传播/散射算子", size=16, bold=True)
    add_label(slide, x, y + Inches(0.45), w, Inches(0.75),
              "∇²E + k²E = 0", size=13, color=C_GREY_DK)
    add_arrow_down(slide, x + w / 2, y + h, y + h + Inches(0.55), dash=True)


def make_top_box_4(slide):
    slide_title_bar(slide, "04 · 顶部算子框 — 守恒约束")
    w, h = Inches(2.6), Inches(1.35)
    x, y = Inches(5.4), Inches(2.8)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.08), w, Inches(0.4),
              "守恒约束", size=16, bold=True)
    add_label(slide, x, y + Inches(0.45), w, Inches(0.75),
              "能量 / 动量 / 质量守恒", size=13, color=C_GREY_DK)
    add_arrow_down(slide, x + w / 2, y + h, y + h + Inches(0.55), dash=True)


def make_left_geometry(slide):
    slide_title_bar(slide, "05 · 左侧 — 几何网格 / 材料分布")
    w, h = Inches(1.55), Inches(3.2)
    x, y = Inches(5.0), Inches(2.0)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.08), w, Inches(0.35),
              "几何规则约束", size=11, bold=True)
    draw_mesh_icon(slide, x + w / 2, y + h * 0.45, w, h * 0.55)
    add_label(slide, x, y + h - Inches(0.55), w, Inches(0.45),
              "几何网格\n材料分布", size=12, bold=True)
    add_double_arrow_h(slide, x + w, y + h / 2, x + w + Inches(0.55), y + h / 2)


def make_neural_network(slide):
    slide_title_bar(slide, "06 · 中部 — 神经网络层（6层）")
    layer_colors = [C_BLUE, C_GREY_DK, C_TEAL, C_WHITE, C_GREY_DK, C_BLUE_LT]
    neuron_colors = [C_BLUE, C_GREY, C_TEAL, C_GREY_LT, C_GREY, C_BLUE_LT]
    n_layers = 6
    n_neurons = 7
    layer_w = Inches(0.55)
    gap = Inches(0.18)
    total_w = n_layers * layer_w + (n_layers - 1) * gap
    x0 = (SLIDE_W - total_w) / 2
    y0 = Inches(1.8)
    layer_h = Inches(3.6)
    neuron_r = Inches(0.11)
    neuron_gap = (layer_h - Inches(0.5)) / (n_neurons - 1)

    layer_centers = []
    neuron_positions = []

    for li in range(n_layers):
        lx = x0 + li * (layer_w + gap)
        add_round_box(slide, lx, y0, layer_w, layer_h,
                      fill=RGBColor(0xFF, 0xFF, 0xFF), line=layer_colors[li], line_w=1.5)
        cx = lx + layer_w / 2
        layer_centers.append(cx)
        positions = []
        ny = y0 + Inches(0.25)
        for ni in range(n_neurons):
            if ni == n_neurons // 2:
                add_label(slide, cx - Inches(0.08), ny - Inches(0.05),
                          Inches(0.16), Inches(0.2), "⋮", size=14, color=C_GREY_DK)
                ny += neuron_gap
                continue
            add_oval(slide, cx - neuron_r, ny - neuron_r, neuron_r * 2,
                     neuron_colors[li], line=layer_colors[li], line_w=0.8)
            positions.append((cx, ny))
            ny += neuron_gap
        neuron_positions.append(positions)

    random.seed(42)
    for li in range(n_layers - 1):
        for (x1, y1) in neuron_positions[li]:
            for (x2, y2) in neuron_positions[li + 1]:
                if random.random() < 0.55:
                    add_line(slide, x1, y1, x2, y2, C_LINE, 0.4)


def make_right_decoder(slide):
    slide_title_bar(slide, "07 · 右侧 — 物理解码器（算子输出）")
    w, h = Inches(1.55), Inches(3.2)
    x, y = Inches(6.8), Inches(2.0)
    add_round_box(slide, x, y, w, h)
    add_label(slide, x, y + Inches(0.06), w, Inches(0.55),
              "物理解码器\n(算子输出)", size=11, bold=True)
    draw_radar_icon(slide, x + w / 2, y + Inches(1.05), Inches(0.9))
    draw_field_icon(slide, x + w / 2, y + Inches(2.0), Inches(1.0), Inches(0.75))
    add_label(slide, x, y + h - Inches(0.45), w, Inches(0.35),
              "... 多源输出", size=11, color=C_GREY_DK)
    add_arrow_right(slide, x - Inches(0.55), y + h / 2, x)


def make_bottom_box_1(slide):
    slide_title_bar(slide, "08 · 底部算子 — 载荷频率算子")
    w, h = Inches(1.7), Inches(1.15)
    x, y = Inches(5.8), Inches(3.0)
    add_round_box(slide, x, y, w, h)
    draw_beam_icon(slide, x + w / 2, y + Inches(0.35), Inches(0.7))
    add_label(slide, x, y + Inches(0.55), w, Inches(0.5),
              "载荷频率\n算子", size=12, bold=True)
    add_arrow_up(slide, x + w / 2, y, y - Inches(0.5))


def make_bottom_box_2(slide):
    slide_title_bar(slide, "09 · 底部算子 — 边界条件")
    w, h = Inches(1.7), Inches(1.15)
    x, y = Inches(5.8), Inches(3.0)
    add_round_box(slide, x, y, w, h)
    draw_boundary_icon(slide, x + w / 2, y + Inches(0.35), Inches(0.75))
    add_label(slide, x, y + Inches(0.55), w, Inches(0.5),
              "边界条件", size=12, bold=True)
    add_arrow_up(slide, x + w / 2, y, y - Inches(0.5))


def make_bottom_box_3(slide):
    slide_title_bar(slide, "10 · 底部算子 — 传播/散射算子")
    w, h = Inches(1.7), Inches(1.15)
    x, y = Inches(5.8), Inches(3.0)
    add_round_box(slide, x, y, w, h)
    draw_wave_icon(slide, x + w / 2, y + Inches(0.35), Inches(0.85))
    add_label(slide, x, y + Inches(0.55), w, Inches(0.5),
              "传播/散射\n算子", size=12, bold=True)
    add_arrow_up(slide, x + w / 2, y, y - Inches(0.5))


def make_bottom_box_4(slide):
    slide_title_bar(slide, "11 · 底部算子 — 守恒约束")
    w, h = Inches(1.7), Inches(1.15)
    x, y = Inches(5.8), Inches(3.0)
    add_round_box(slide, x, y, w, h)
    draw_scale_icon(slide, x + w / 2, y + Inches(0.38), Inches(0.75))
    add_label(slide, x, y + Inches(0.55), w, Inches(0.5),
              "守恒约束", size=12, bold=True)
    add_arrow_up(slide, x + w / 2, y, y - Inches(0.5))


def make_footer_title(slide):
    slide_title_bar(slide, "12 · 底部标题条")
    w, h = Inches(8.5), Inches(0.75)
    x, y = Inches(2.4), Inches(3.2)
    box = add_round_box(slide, x, y, w, h, fill=C_WHITE, line=C_TEAL, line_w=2.0)
    add_label(slide, x, y, w, h,
              "物理模块 + 神经网络层 深度耦合", size=22, bold=True, color=C_TEAL)


def make_connection_lines(slide):
    slide_title_bar(slide, "13 · 连接线与反馈回路")
    y = Inches(3.5)
    add_line(slide, Inches(1.5), y, Inches(11.8), y, C_WHITE, 1.2,
             MSO_LINE_DASH_STYLE.DASH)
    add_arrow_down(slide, Inches(3.5), Inches(2.5), Inches(3.5), dash=False)
    add_arrow_down(slide, Inches(6.5), Inches(2.5), Inches(6.5), dash=False)
    add_arrow_down(slide, Inches(9.5), Inches(2.5), Inches(9.5), dash=False)
    add_label(slide, Inches(1.0), Inches(4.0), Inches(11.0), Inches(0.5),
              "（虚线底栏 + 各层虚线箭头，可按需复制到拼装页）",
              size=12, color=C_GREY_DK)


def make_full_assembly(slide):
    """完整拼装参考页（深色背景）"""
    fill = slide.background.fill
    fill.solid()
    fill.fore_color.rgb = C_BG

    add_label(slide, Inches(0.3), Inches(0.1), Inches(12.7), Inches(0.4),
              "完整拼装参考（所有元素可从此页复制，或从前页分别插入）",
              size=14, bold=True, color=C_WHITE, align=PP_ALIGN.LEFT)

    # 顶部四框
    top_y = Inches(0.55)
    top_specs = [
        ("连续方程算子", "∇·(ρv)+∂ρ/∂t=0"),
        ("边界条件", "B(u)=g"),
        ("传播/散射算子", "∇²E+k²E=0"),
        ("守恒约束", "能量/动量/质量守恒"),
    ]
    tw, th = Inches(2.35), Inches(0.95)
    tx0 = Inches(0.55)
    tg = Inches(0.28)
    top_xs = []
    for i, (title, formula) in enumerate(top_specs):
        tx = tx0 + i * (tw + tg)
        top_xs.append(tx + tw / 2)
        add_round_box(slide, tx, top_y, tw, th, fill=C_WHITE)
        add_label(slide, tx, top_y + Inches(0.04), tw, Inches(0.32),
                  title, size=10, bold=True, color=C_BLACK)
        add_label(slide, tx, top_y + Inches(0.36), tw, Inches(0.5),
                  formula, size=9, color=C_GREY_DK)

    # 神经网络区域
    nn_y0 = Inches(1.65)
    nn_h = Inches(2.55)
    layer_colors = [C_BLUE, C_GREY_DK, C_TEAL, C_WHITE, C_GREY_DK, C_BLUE_LT]
    neuron_colors = [C_BLUE, C_GREY, C_TEAL, C_GREY_LT, C_GREY, C_BLUE_LT]
    n_layers, n_neurons = 6, 5
    layer_w = Inches(0.42)
    gap = Inches(0.12)
    nn_x0 = Inches(3.05)
    neuron_positions = []
    layer_centers = []

    for li in range(n_layers):
        lx = nn_x0 + li * (layer_w + gap)
        add_round_box(slide, lx, nn_y0, layer_w, nn_h,
                      fill=RGBColor(0x18, 0x18, 0x18), line=layer_colors[li], line_w=1.2)
        cx = lx + layer_w / 2
        layer_centers.append(cx)
        positions = []
        ny = nn_y0 + Inches(0.18)
        ngap = (nn_h - Inches(0.36)) / (n_neurons - 1)
        nr = Inches(0.07)
        for ni in range(n_neurons):
            if ni == n_neurons // 2:
                add_label(slide, cx - Inches(0.06), ny - Inches(0.04),
                          Inches(0.12), Inches(0.15), "⋮", size=10, color=C_GREY)
                ny += ngap
                continue
            add_oval(slide, cx - nr, ny - nr, nr * 2, neuron_colors[li],
                     line=layer_colors[li], line_w=0.6)
            positions.append((cx, ny))
            ny += ngap
        neuron_positions.append(positions)

    random.seed(7)
    for li in range(n_layers - 1):
        for p1 in neuron_positions[li]:
            for p2 in neuron_positions[li + 1]:
                if random.random() < 0.5:
                    add_line(slide, p1[0], p1[1], p2[0], p2[1], C_LINE, 0.35)

    # 顶部虚线箭头
    for i, cx in enumerate([layer_centers[0], layer_centers[1],
                            layer_centers[3], layer_centers[5]]):
        add_arrow_down(slide, cx, top_y + th, nn_y0, color=C_WHITE, dash=True)

    # 左侧
    lw, lh = Inches(1.15), Inches(2.55)
    lx, ly = Inches(1.55), nn_y0
    add_round_box(slide, lx, ly, lw, lh, fill=RGBColor(0x18, 0x18, 0x18), line=C_WHITE)
    add_label(slide, lx, ly + Inches(0.04), lw, Inches(0.3),
              "几何规则约束", size=8, bold=True, color=C_WHITE)
    draw_mesh_icon(slide, lx + lw / 2, ly + lh * 0.45, lw, lh * 0.5, C_GREY)
    add_label(slide, lx, ly + lh - Inches(0.42), lw, Inches(0.38),
              "几何网格\n材料分布", size=9, bold=True, color=C_WHITE)
    add_double_arrow_h(slide, lx + lw, ly + lh / 2, nn_x0, ly + lh / 2)

    # 右侧
    rx = Inches(9.65)
    add_round_box(slide, rx, ly, lw, lh, fill=RGBColor(0x18, 0x18, 0x18), line=C_WHITE)
    add_label(slide, rx, ly + Inches(0.04), lw, Inches(0.42),
              "物理解码器\n(算子输出)", size=8, bold=True, color=C_WHITE)
    draw_radar_icon(slide, rx + lw / 2, ly + Inches(0.95), Inches(0.65), C_GREY)
    draw_field_icon(slide, rx + lw / 2, ly + Inches(1.75), Inches(0.7), Inches(0.5), C_GREY)
    add_label(slide, rx, ly + lh - Inches(0.32), lw, Inches(0.28),
              "... 多源输出", size=8, color=C_GREY)
    add_arrow_right(slide, layer_centers[-1] + layer_w / 2 + Inches(0.05),
                    ly + lh / 2, rx)

    # 底部四框
    bot_y = Inches(4.55)
    bw, bh = Inches(1.45), Inches(0.85)
    bot_specs = [
        ("载荷频率\n算子", draw_beam_icon),
        ("边界条件", draw_boundary_icon),
        ("传播/散射\n算子", draw_wave_icon),
        ("守恒约束", draw_scale_icon),
    ]
    bx0 = Inches(2.15)
    bg = Inches(0.22)
    bot_centers = []
    for i, (txt, icon_fn) in enumerate(bot_specs):
        bx = bx0 + i * (bw + bg)
        bot_centers.append(bx + bw / 2)
        add_round_box(slide, bx, bot_y, bw, bh, fill=C_WHITE)
        if icon_fn == draw_wave_icon:
            icon_fn(slide, bx + bw / 2, bot_y + Inches(0.28), Inches(0.65))
        elif icon_fn == draw_scale_icon:
            icon_fn(slide, bx + bw / 2, bot_y + Inches(0.3), Inches(0.6))
        else:
            icon_fn(slide, bx + bw / 2, bot_y + Inches(0.28), Inches(0.6))
        add_label(slide, bx, bot_y + Inches(0.42), bw, Inches(0.4),
                  txt, size=9, bold=True, color=C_BLACK)

    for cx, li in zip(bot_centers, [0, 1, 3, 5]):
        add_arrow_up(slide, cx, bot_y, nn_y0 + nn_h, color=C_WHITE)

    # 底栏虚线
    dash_y = Inches(5.55)
    add_line(slide, Inches(1.3), dash_y, Inches(12.0), dash_y, C_WHITE, 1.0,
             MSO_LINE_DASH_STYLE.DASH)

    # 底部标题
    fw, fh = Inches(7.5), Inches(0.6)
    fx = (SLIDE_W - fw) / 2
    fy = Inches(6.15)
    add_round_box(slide, fx, fy, fw, fh, fill=RGBColor(0x18, 0x18, 0x18),
                  line=C_TEAL, line_w=2.0)
    add_label(slide, fx, fy, fw, fh,
              "物理模块 + 神经网络层 深度耦合", size=18, bold=True, color=C_TEAL)


def make_usage_slide(slide):
    slide_title_bar(slide, "使用说明")
    items = [
        "本文件共 15 页：第 1–13 页为独立子元素，第 14 页为完整拼装参考，第 15 页为说明。",
        "所有中文、公式均为可编辑文本框，双击即可修改字体与内容。",
        "建议做法：打开对应页 → Ctrl+A 全选 → 复制 → 粘贴到目标 PPT。",
        "图标由 PPT 基本形状组合而成，可在「选择窗格」中单独调整。",
        "若需公式编辑器格式，可选中文本后 插入 → 公式 重新录入。",
        "神经网络连线为独立线条，可在选择窗格中批量删除或重画。",
    ]
    y = Inches(1.2)
    for item in items:
        add_label(slide, Inches(0.8), y, Inches(11.8), Inches(0.55),
                  "• " + item, size=14, color=C_GREY_DK, align=PP_ALIGN.LEFT)
        y += Inches(0.62)


def build():
    prs = new_prs()
    makers = [
        make_top_box_1,
        make_top_box_2,
        make_top_box_3,
        make_top_box_4,
        make_left_geometry,
        make_neural_network,
        make_right_decoder,
        make_bottom_box_1,
        make_bottom_box_2,
        make_bottom_box_3,
        make_bottom_box_4,
        make_footer_title,
        make_connection_lines,
    ]
    for fn in makers:
        slide = blank_slide(prs, dark=False)
        fn(slide)

    full = blank_slide(prs, dark=True)
    make_full_assembly(full)

    usage = blank_slide(prs, dark=False)
    make_usage_slide(usage)

    prs.save(str(OUT_PPTX))
    print(f"已生成: {OUT_PPTX}")
    print(f"共 {len(prs.slides)} 页幻灯片")


if __name__ == "__main__":
    build()