整体方向是对的，你现在从 EchoNet-Dynamic 的 LV blood-pool 分割出发，把“全局 EF/FAC 类指标”升级到“局部节段性室壁运动曲线”，这个转向非常适合冠心病任务。EchoNet-Dynamic 原始定位确实更偏向左室分割、EF 估计和 HFrEF 分类，而冠心病更依赖区域室壁运动异常、节段供血域聚合、应激前后变化和临床风险因子联合判断。(GitHub)

但你的汇报里有几处建议改一下：

1. A4C 单切面容积不要写得太像临床标准 LVEF。
   A4C 单切面 Simpson 或旋转体积分可以作为 white-box proxy，但正式 LV 容积推荐通常基于 A4C + A2C 的 biplane Simpson，并且要避免心尖缩短导致容积低估。你可以把它写成“单平面估算容积 / LVEF Proxy”，多切面后再升级为“双平面或多平面联合估算容积”。(ASE)

2. “18 个标准解剖节段”建议改成“18 个切面投影节段”。
   临床通用是 AHA 16/17 节段模型，17 节段模型还包含 apical cap，常用于灌注或跨模态比较。你现在的 A4C/A2C/A3C 每个切面 6 段很适合算法提特征，但它更准确的叫法是“18 个 view-segments / 投影节段”，后续需要映射回 AHA 16/17 节段和 LAD、LCx、RCA 供血域。(ASE)

3. 冠心病不能只依赖静息收缩幅度。
   静息 RWMA 对陈旧梗死、明显狭窄或冬眠心肌有价值，但稳定冠心病在静息状态可能没有明显异常。应激超声中，缺血反应的经典定义是“原本正常节段在负荷下出现新的室壁运动异常，或原本异常节段在负荷下进一步恶化”。所以如果你没有负荷/应激视频，建议表述为“冠心病风险预测 / 供血域受累提示”，不要写成“病变血管精准定位”的临床定论。(ScienceDirect)

4. 灰度纹理部分可以保留，但要加质量控制。
   超声灰度受增益、TGC、探头频率、深度、压缩、机器厂商影响很大。灰度纹理可作为组织学补充，但最好同时加入 acquisition metadata、图像质量分数、分割置信度、foreshortening 评分、帧率归一化等控制变量。

下面这段可以直接补进你的“冠心病预测所需特征列表”里，风格尽量按你原文延续。

---

冠心病预测所需补充特征列表

9．标准化节段壁运动评分与冠脉供血域聚合指标
在完成 18 个切面投影节段的局部径向距离曲线提取后，进一步将各节段映射至 AHA 16/17 标准左心室节段模型，并按照 LAD、LCx、RCA 三大冠状动脉供血区域进行区域聚合。该模块用于把“单个像素级曲线异常”升级为“临床可解释的供血域异常模式”，从而提高冠心病任务中的病变血管归因能力。AHA 17 节段模型是跨超声、核医学、CT、MRI 等心脏影像常用的标准化节段命名体系，但冠脉供血存在个体解剖差异，因此模型输出应表述为“疑似供血域受累概率”，而非绝对病变血管诊断。(ScienceDirect)

（1）标准化节段壁运动评分：将每个节段的局部径向缩短率、向内收缩速度、达峰时间及后收缩异常综合转化为正常、运动减弱、无运动、反向运动等分级评分。用于构建类临床 Wall Motion Score 的白箱解释指标。
（2）左心室整体壁运动评分指数（WMSI）：对全部标准化节段评分进行平均，得到全局壁运动异常负荷。该指标可作为 LVEF 之外的冠心病风险分层指标，尤其适用于 LVEF 尚未明显下降但局部节段已经异常的患者。
（3）LAD 供血域异常负荷：聚合前壁、前间隔、心尖相关节段的缩短率下降、达峰延迟和速度下降程度，用于提示左前降支相关缺血或梗死风险。
（4）LCx 供血域异常负荷：聚合外侧壁、后外侧壁或下外侧壁相关节段的运动异常强度，用于提示左回旋支相关供血受累。
（5）RCA 供血域异常负荷：聚合下壁、下间隔及部分后壁相关节段的运动异常强度，用于提示右冠状动脉或后降支相关供血受累。
（6）连续异常节段数量：统计同一供血域内相邻异常节段的数量与空间连续性。冠心病导致的节段异常通常具有供血域聚集特征，该指标可用于区分真实区域性缺血与单个切面分割噪声。

10．静息—负荷差分型缺血诱发指标
若后续数据集中包含运动负荷、药物负荷或应激超声视频，应在静息状态与峰值负荷状态之间构建差分特征。该板块是冠心病预测中最具疾病特异性的升级模块，因为冠心病的核心病理并非单纯静息泵血下降，而是在心肌耗氧增加时，受狭窄冠脉供血限制而诱发区域性运动恶化。应激超声的缺血判读核心正是新发或加重的区域室壁运动异常。(ScienceDirect)

（1）18节段负荷后径向缩短率下降量：计算峰值负荷状态相对于静息状态的局部缩短率差值。用于捕捉静息尚可、负荷后暴露的诱发性缺血。
（2）18节段负荷后达峰时间延迟量：计算各节段在负荷前后收缩达峰时间的变化。缺血节段在负荷状态下可能出现机械收缩延迟或收缩终止不完全。
（3）18节段负荷后最大收缩速度衰减量：衡量局部心肌在供氧压力增加时是否出现向内运动速度下降。
（4）负荷诱发 WMSI 增量：计算负荷后 WMSI 相对于静息 WMSI 的增幅，用于表示诱发性缺血总负荷。
（5）左心室收缩储备指标：计算负荷后 LVEF、FAC Proxy、ESV 或局部缩短率是否按预期改善。若负荷后收缩储备不足、ESV 不降反升或局部节段运动恶化，可作为高危冠心病提示信号。

11．心肌应变替代指标与后收缩异常指标
在现有内膜边界径向距离曲线的基础上，进一步构建类 strain 的时序形变指标。相比单纯“距离缩短多少”，应变类指标更关注“同一节段在心动周期中相对自身初始长度发生了多少形变”，可提高跨患者、跨切面、跨设备的可比性。既往研究与指南性文件均强调，纵向应变、早期收缩拉长和后收缩缩短可用于量化常规肉眼壁运动难以识别的细微缺血性形变异常。(Heart)

（1）18节段局部径向应变 Proxy：以舒张末期径向距离为基线，计算整个心动周期内的相对缩短曲线。用于消除不同患者心腔大小、探头放大倍数和切面尺度差异。
（2）全局纵向应变 Proxy：基于心尖至瓣环长轴长度变化、节段中心线运动和内膜轮廓时序形变，构建近似 GLS 的白箱替代指标。用于捕捉 LVEF 正常但心肌纵向收缩已经受损的早期冠心病信号。
（3）18节段后收缩缩短量（PSS）：识别主动脉瓣关闭或全局收缩末期之后仍继续向内缩短的节段。缺血心肌常出现收缩时相滞后，后收缩缩短可作为局部缺血、顿抑或冬眠心肌的敏感动力学信号。
（4）18节段后收缩指数（PSI）：计算收缩末期之后额外缩短量占总缩短量的比例。该指标用于把“达峰延迟”进一步定量化，区分单纯慢收缩与真正的收缩后异常。
（5）早期收缩拉长指数（ESL）：统计收缩早期节段反而向外扩张或长度增加的异常形变幅度。该指标可用于捕捉缺血心肌在等容收缩期出现的反常被动拉伸现象。

12．心肌壁厚度与收缩期增厚指标
当前 EchoNet-Dynamic 输出主要是左心室血池语义分割，因此更适合计算内膜运动和心腔面积变化；但冠心病超声判读不仅看内膜是否向内运动，也看心肌壁自身是否在收缩期增厚。建议下一阶段引入心外膜边界或心肌环形 ROI 分割，将“血池边界运动”升级为“心肌壁真实增厚与变薄”的组织级特征。

（1）18节段舒张末期心肌壁厚度：测量各节段心内膜至心外膜的局部厚度。用于识别陈旧性心肌梗死后局部壁变薄、瘢痕化或室壁重构。
（2）18节段收缩期壁增厚率：计算收缩末期相对于舒张末期的局部心肌厚度增加比例。冠心病缺血节段可表现为内膜运动幅度下降，同时收缩期壁增厚不足。
（3）局部变薄伴高回声复合特征：将壁厚度下降、灰度均值升高、纹理异质性增强进行联合建模。用于提示陈旧性梗死、纤维化或瘢痕心肌。
（4）内膜运动—心肌增厚解耦指标：比较同一节段的内膜向内位移与心肌壁增厚是否一致。若内膜被邻近正常节段牵拉而出现假性运动，但心肌壁自身增厚不足，可提示 tethering 效应或局部主动收缩能力下降。

13．冠脉血流储备与心肌灌注补充指标
若后续数据来源不仅包含普通 B-mode 视频，还包含多普勒、造影或应激超声协议，可进一步补充血流与灌注维度。冠心病的根本问题是冠脉供血不足，室壁运动异常是供血不足后的力学表现，因此血流储备与灌注特征能够为模型提供更靠近病因层的证据。欧洲应激超声 ABCDE 协议中，区域壁运动、肺 B 线、左室收缩储备、LAD 冠脉血流速度储备和心率储备被组合用于更全面的风险分层。(OUP Academic)

（1）LAD 冠脉血流速度储备（CFVR-LAD）：在静息与负荷状态下测量 LAD 血流速度变化，用于评估冠脉微循环与大血管供血储备能力。
（2）心肌造影灌注充盈速度：基于超声造影剂在局部心肌 ROI 内的再充盈曲线，提取灌注速度、峰值强度和达峰时间。用于捕捉室壁运动异常出现之前的区域灌注不足。
（3）灌注—运动不匹配指标：若某供血域灌注下降但运动尚正常，可提示早期可逆性缺血；若灌注下降且运动异常，则提示更高危的供血受限或既往损伤。
（4）肺 B 线负荷反应指标：负荷后肺 B 线增加可提示运动诱发的充盈压升高和心肺储备下降，可作为冠心病风险分层的辅助维度。

14．临床似然度与冠脉标签监督指标
冠心病预测不能只依赖图像特征。建议将图像白箱特征、黑箱视频嵌入、临床危险因素、症状学信息、心电图和冠脉影像标签整合为统一多模态学习任务。ESC 2024 慢性冠脉综合征指南强调，阻塞性冠心病的评估应结合年龄、性别、症状和危险因素构建风险因子加权的临床似然度模型，而不是只看单一影像指标。(European Society of Cardiology)

（1）胸痛症状学指标：包含典型心绞痛、非典型胸痛、劳力性胸闷、呼吸困难、静息痛、症状持续时间及诱发缓解因素。用于构建冠心病预测的临床先验概率。
（2）静息心电图异常指标：包含 ST-T 改变、病理性 Q 波、束支传导阻滞、房颤、室早及既往心梗提示性改变。用于补充超声无法直接观察到的电生理缺血痕迹。
（3）实验室危险因素指标：包含 LDL-C、HbA1c、空腹血糖、肌酐/eGFR、hs-CRP、肌钙蛋白及 BNP/NT-proBNP。用于捕捉动脉粥样硬化负荷、糖代谢异常、肾功能风险和心肌损伤背景。
（4）冠脉 CTA / CAG / FFR 标签：将模型标签从单纯“是否冠心病”细化为是否存在阻塞性冠脉狭窄、狭窄程度分级、病变血管类别、单支/双支/三支病变、左主干受累及功能学缺血证据。用于提升模型从“风险筛查”到“病变血管定位”的监督质量。
（5）患者级数据切分指标：所有视频、切面和心动周期必须按患者级划分训练集、验证集和测试集，避免同一患者不同切面泄漏导致模型性能虚高。

15．图像质量控制与跨设备归一化指标
冠心病模型比心衰 EF 模型更容易受到切面角度、心尖缩短、帧率、分割噪声和机器参数干扰。因此建议单独建立质量控制特征层，将“可解释生理异常”与“采集伪差”尽量拆开，避免模型把设备差异、增益差异或切面差异误学成冠心病特征。

（1）切面分类置信度：分别记录 A4C、A2C、A3C 的自动切面识别概率，剔除非标准切面或严重偏轴视频。
（2）心尖缩短评分：评估心尖是否被截短、长轴是否充分展开。心尖缩短会导致 LV 容积和局部运动幅度系统性低估。(ASE)
（3）分割置信度与轮廓稳定性：记录每帧 LV mask 面积突变、边界抖动、缺失帧比例和时序平滑残差。用于识别由分割失败导致的假性节段运动异常。
（4）帧率与心动周期归一化：将绝对帧号转换为心动周期百分比，将速度和加速度按真实秒数、心率和 RR 间期进行归一化。用于保证不同视频帧率和心率下的达峰时间、速度、加速度具有可比性。
（5）像素—物理尺度归一化：若 DICOM 中可获得像素间距，应将径向距离由 pixel 转换为 mm；若仅有 AVI，则至少用 LV 长轴长度、舒张末期面积或体表面积进行尺度归一化。
（6）超声机器参数记录：包含设备厂商、探头频率、深度、增益、动态范围、压缩参数和是否使用谐波成像。用于降低灰度纹理特征在跨中心训练中的域偏移风险。

---

你现在这张图里的 6 段径向距离曲线，已经能支撑“局部节段收缩幅度、达峰时间、速度、不同步性”这几个白箱指标；下一步最关键的是把它从“单切面曲线”提升成“标准节段—供血域—患者级标签”的三层结构。也就是说，算法层面继续保留 18 个投影节段，但汇报和建模输出层面建议落到 AHA 16/17 节段 + LAD/LCx/RCA 供血域 + WMSI/应激差分/PSI 这一套更贴近冠心病临床语义的体系。

你的情况不建议继续用“第 0 帧 = ED、txt 里的 ES 毫秒数直接换算帧号”这条路线。更稳的方案是：

txt 只提供相位，不提供绝对时间。
比如你给的 txt 中 Total 最低谷在 319.54 ms，整段周期约 798.86 ms，所以 ES 相位约为 319.54 / 798.86 = 0.40。后续不再用“319.54 ms 对应多少帧”，而是用：

text
ES帧 = 选中的ED帧 + 0.40 × 当前视频自身估计出来的RR帧长

这样即使 AVI 转换后播放速度变了，只要帧序列没乱，仍然能按心动周期相位找 ES。

同时，ED 不建议固定第 0 帧，而是先在视频内估计多个候选 R 峰或周期起点，再通过图像清晰度、探头稳定度、边界帧安全性来自动选择质量最好的一轮心动周期。A3C 不能直接用 EchoNet-Dynamic 的 LV 面积最大/最小法，这个相位法反而更通用。

目前公开资源上，EchoNet-Dynamic 明确是 A4C 为主，提供 EF、EDV、ESV 和 LV tracing；CAMUS 公开数据是 A2C/A4C；EchoNet-LVH 主要是 PLAX，不是 A3C。A3C/心尖长轴相关自动轮廓有论文工作，但我没有看到像 EchoNet-Dynamic 或 CAMUS 这样成熟、通用、开箱即用且覆盖 A3C 的公开训练权重。(AI in Medicine & Imaging)

下面是按你现有脚本风格改的版本。它的核心变化是：Results.txt 只取 ES 相位；视频本身估计 RR 帧长；ED 在多个候选周期中选质量最好的一轮；同时输出 QC 表，方便人工复核。

python
# -*- coding: utf-8 -*-
"""
dump_esed_frames_robust.py

目标：
1. 不再假设第 0 帧一定是可用 ED；
2. 不再把 Results.txt 里的毫秒数直接换算成帧号；
3. Results.txt 只用于提取 ES 在一个心动周期中的相位；
4. 视频自身估计 RR 帧长；
5. 在多个候选 ED 周期中，根据图像质量与探头稳定性自动选择最佳周期；
6. 输出 ED/ES 关键帧和 QC 表，供医生绘制掩膜前复核。

依赖：
pip install opencv-python numpy pandas
"""

import math
import argparse
from pathlib import Path

import cv2
import numpy as np
import pandas as pd


# =========================
# 基础工具
# =========================

def get_video_meta(video_path: Path):
    cap = cv2.VideoCapture(str(video_path))
    fps = cap.get(cv2.CAP_PROP_FPS)
    if fps is None or fps <= 1 or fps > 300 or math.isnan(fps):
        fps = 50.0
    n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    cap.release()
    return float(fps), int(n), int(w), int(h)


def read_all_frames(video_path: Path):
    cap = cv2.VideoCapture(str(video_path))
    frames = []

    if not cap.isOpened():
        return frames, 50.0

    fps = cap.get(cv2.CAP_PROP_FPS)
    if fps is None or fps <= 1 or fps > 300 or math.isnan(fps):
        fps = 50.0

    while True:
        ok, frame = cap.read()
        if not ok:
            break
        frames.append(frame)

    cap.release()
    return frames, float(fps)


def imwrite_safe(path: Path, image):
    """
    Windows 下 cv2.imwrite 对中文路径有时不稳，这里用 imencode + tofile。
    """
    path.parent.mkdir(parents=True, exist_ok=True)
    ext = path.suffix.lower()
    if ext not in [".png", ".jpg", ".jpeg", ".bmp"]:
        ext = ".png"

    ok, buf = cv2.imencode(ext, image)
    if ok:
        buf.tofile(str(path))
        return True
    return cv2.imwrite(str(path), image)


def smooth_1d(x, window=5):
    x = np.asarray(x, dtype=np.float32)
    if len(x) < window or window <= 1:
        return x
    pad = window // 2
    xp = np.pad(x, (pad, pad), mode="edge")
    kernel = np.ones(window, dtype=np.float32) / float(window)
    return np.convolve(xp, kernel, mode="valid")


def fill_nan_1d(x):
    x = np.asarray(x, dtype=np.float32)
    idx = np.arange(len(x))
    good = np.isfinite(x)

    if good.sum() == 0:
        return x
    if good.sum() == len(x):
        return x

    return np.interp(idx, idx[good], x[good]).astype(np.float32)


def parse_float_list_from_semicolon_line(line, skip_first=True):
    parts = line.strip().split(";")
    if skip_first:
        parts = parts[1:]

    values = []
    for p in parts:
        p = p.strip().replace(",", ".")
        if p == "":
            continue
        try:
            values.append(float(p))
        except Exception:
            values.append(np.nan)

    return values


# =========================
# Results.txt：只取 ES 相位，不直接取毫秒帧号
# =========================

def parse_strain_txt_for_es_phase(folder_path: Path):
    """
    从患者目录下的 Results.txt 中提取：
    ES_phase = Total longitudinal strain 最低谷所在时间 / 当前 strain 曲线总时长

    注意：
    1. 不使用 t_es_ms 直接换算帧号；
    2. 因为 txt 不一定和视频一一对应，所以这里只把它当作患者级 ES 相位先验；
    3. 多个 txt 时取中位数，增强鲁棒性。
    """
    txt_files = list(folder_path.glob("*Results*.txt"))
    if not txt_files:
        txt_files = list(folder_path.glob("*.txt"))

    phase_candidates = []

    for txt_p in txt_files:
        try:
            with open(txt_p, "r", encoding="utf-8", errors="ignore") as f:
                lines = f.readlines()

            in_strain_section = False
            time_vals = None
            total_vals = None

            for raw in lines:
                line = raw.strip()

                if "Longitudinal Strain" in line:
                    in_strain_section = True
                    continue

                if not in_strain_section:
                    continue

                if line.startswith("Time") and ";" in line:
                    time_vals = parse_float_list_from_semicolon_line(line, skip_first=True)

                elif line.startswith("Total;"):
                    total_vals = parse_float_list_from_semicolon_line(line, skip_first=True)
                    break

            if time_vals is None or total_vals is None:
                continue

            L = min(len(time_vals), len(total_vals))
            if L < 10:
                continue

            t = np.asarray(time_vals[:L], dtype=np.float32)
            y = fill_nan_1d(np.asarray(total_vals[:L], dtype=np.float32))

            if not np.isfinite(t).all() or not np.isfinite(y).all():
                continue

            rr_ms = float(t[-1] - t[0])
            if rr_ms <= 200:
                continue

            y_s = smooth_1d(y, window=5)

            # 避免开头/末尾噪声抢最低谷，只在 5%~85% 区间内找 Total 最低谷
            left = max(1, int(0.05 * L))
            right = min(L, int(0.85 * L))
            if right <= left + 2:
                left, right = 0, L

            local_idx = int(np.argmin(y_s[left:right]))
            min_idx = left + local_idx

            t_es_ms = float(t[min_idx] - t[0])
            es_phase = t_es_ms / rr_ms

            # 正常静息状态下 ES 通常在心动周期前半段；
            # 范围放宽一些，避免低 EF 或传导延迟病例被误删。
            if 0.20 <= es_phase <= 0.65:
                phase_candidates.append({
                    "phase": float(es_phase),
                    "txt_name": txt_p.name,
                    "t_es_ms": float(t[min_idx]),
                    "rr_ms": float(rr_ms),
                    "min_total_strain": float(y[min_idx])
                })

        except Exception:
            continue

    if not phase_candidates:
        return None, None

    phases = [x["phase"] for x in phase_candidates]
    phase_median = float(np.median(phases))

    txt_summary = "|".join([
        f"{x['txt_name']}:phase={x['phase']:.3f},t_es={x['t_es_ms']:.1f}ms"
        for x in phase_candidates
    ])

    return phase_median, txt_summary


# =========================
# 视频周期估计：用帧序列自身估计 RR 帧长
# =========================

def crop_bmode_gray(frame):
    """
    裁掉底部 ECG/文字区域，保留主要超声扇形图像区域。
    如果你的设备 ECG 在顶部或右侧，需要微调这里的比例。
    """
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    h, w = gray.shape

    y1 = int(0.03 * h)
    y2 = int(0.82 * h)
    x1 = int(0.04 * w)
    x2 = int(0.96 * w)

    return gray[y1:y2, x1:x2]


def make_small_roi(frame, size=128):
    roi = crop_bmode_gray(frame)
    roi = cv2.resize(roi, (size, size), interpolation=cv2.INTER_AREA)
    roi = cv2.GaussianBlur(roi, (5, 5), 0)
    roi = cv2.normalize(roi, None, 0, 1, cv2.NORM_MINMAX)
    return roi.astype(np.float32)


def compute_motion_signal(frames):
    """
    计算相邻帧差异，用于估计心动周期。
    不依赖 LV 分割，因此 A2C/A3C/A4C 都能跑。
    """
    if len(frames) < 3:
        return np.zeros(len(frames), dtype=np.float32)

    rois = [make_small_roi(f, size=128) for f in frames]

    motion = [0.0]
    for i in range(1, len(rois)):
        diff = np.mean(np.abs(rois[i] - rois[i - 1]))
        motion.append(float(diff))

    motion = np.asarray(motion, dtype=np.float32)
    motion = smooth_1d(motion, window=5)
    return motion


def estimate_rr_frames_by_autocorr(frames, fps):
    """
    用视频运动信号自相关估计 RR 帧长。
    如果视频只有一个心动周期，无法自相关，就退回 n-1。
    """
    n = len(frames)
    if n < 10:
        return max(1, n - 1), "too_short"

    motion = compute_motion_signal(frames)
    x = motion - float(np.mean(motion))
    std = float(np.std(x))

    if std < 1e-6:
        # 几乎没运动，退回常规估计
        fallback = int(round(0.80 * fps))
        fallback = int(np.clip(fallback, 10, max(10, n - 1)))
        return fallback, "flat_motion_fallback"

    min_lag = max(12, int(round(0.40 * fps)))   # 150 bpm 左右
    max_lag = min(int(round(1.60 * fps)), n // 2)  # 37.5 bpm 左右

    best_lag = None
    best_corr = -1.0

    if max_lag > min_lag + 3:
        for lag in range(min_lag, max_lag + 1):
            a = x[:-lag]
            b = x[lag:]
            denom = float(np.linalg.norm(a) * np.linalg.norm(b))
            if denom <= 1e-8:
                continue
            corr = float(np.dot(a, b) / denom)
            if corr > best_corr:
                best_corr = corr
                best_lag = lag

    if best_lag is not None and best_corr >= 0.10:
        return int(best_lag), f"motion_autocorr_corr={best_corr:.3f}"

    # 如果视频长度接近一个心动周期，直接把全长当作 RR。
    if 20 <= n <= int(round(1.8 * fps)):
        return int(n - 1), "single_cycle_length"

    fallback = int(round(0.80 * fps))
    fallback = int(np.clip(fallback, 10, max(10, n - 1)))
    return fallback, "default_0p8s"


# =========================
# ECG 弱检测：只作为候选 ED，不作为唯一依据
# =========================

def ecg_height_signal_from_frames(frames):
    """
    尝试从视频底部 ECG 区域提取每帧 ECG 的相对高度信号。
    该函数不保证所有设备都有效，所以只作为弱候选。
    """
    sig = []

    for frame in frames:
        h, w = frame.shape[:2]

        # 默认 ECG 在底部 30% 区域
        y1 = int(0.68 * h)
        y2 = int(0.98 * h)
        x1 = int(0.05 * w)
        x2 = int(0.95 * w)

        crop = frame[y1:y2, x1:x2]
        if crop.size == 0:
            sig.append(np.nan)
            continue

        hsv = cv2.cvtColor(crop, cv2.COLOR_BGR2HSV)
        s = hsv[:, :, 1]
        v = hsv[:, :, 2]

        # ECG 线常见为绿色/黄色/白色高亮，阈值故意宽松
        mask = ((s > 45) & (v > 80)) | (v > 220)

        ys = np.where(mask)[0]
        if len(ys) < 20:
            sig.append(np.nan)
            continue

        # R 波最高点对应 y 更小，这里取负号使 R 波变成峰值
        y_top = float(np.percentile(ys, 5))
        sig.append(-y_top)

    sig = np.asarray(sig, dtype=np.float32)
    sig = fill_nan_1d(sig)

    if len(sig) < 5 or not np.isfinite(sig).all():
        return None

    sig_s = smooth_1d(sig, window=5)

    # 如果几乎不变，说明没提到有效 ECG 动态
    if float(np.std(sig_s)) < 1.0:
        return None

    return sig_s


def find_peaks_1d(x, min_distance):
    """
    简单局部峰检测，不依赖 scipy。
    """
    x = np.asarray(x, dtype=np.float32)
    if len(x) < 5:
        return []

    threshold = float(np.percentile(x, 75))
    raw_peaks = []

    for i in range(1, len(x) - 1):
        if x[i] >= threshold and x[i] >= x[i - 1] and x[i] >= x[i + 1]:
            raw_peaks.append((i, float(x[i])))

    if not raw_peaks:
        return []

    # 先按峰高排序，再做距离抑制
    raw_peaks = sorted(raw_peaks, key=lambda z: z[1], reverse=True)

    selected = []
    for idx, amp in raw_peaks:
        if all(abs(idx - j) >= min_distance for j in selected):
            selected.append(idx)

    selected = sorted(selected)
    return selected


def detect_ecg_r_peaks(frames, fps, rr_frames):
    sig = ecg_height_signal_from_frames(frames)
    if sig is None:
        return [], "ecg_not_detected"

    min_distance = max(8, int(round(0.45 * rr_frames)))
    peaks = find_peaks_1d(sig, min_distance=min_distance)

    # 如果只找到一堆很奇怪的峰，宁可不用
    if len(peaks) == 0:
        return [], "ecg_no_peak"

    return peaks, f"ecg_peaks={peaks}"


# =========================
# 质量评分：自动避开探头未稳定周期
# =========================

def frame_quality_score(frame):
    """
    单帧图像质量粗评分：
    - 清晰度：Laplacian 方差
    - 对比度：95%-5% 灰度差
    - 非黑区域比例
    - 过曝比例惩罚

    该分数不是医学质量评分，只是用于在同一视频内选择更稳的一轮周期。
    """
    roi = crop_bmode_gray(frame)

    lap_var = float(cv2.Laplacian(roi, cv2.CV_64F).var())
    contrast = float(np.percentile(roi, 95) - np.percentile(roi, 5))
    nonblack = float(np.mean(roi > 10))
    saturated = float(np.mean(roi > 245))

    score = np.log1p(lap_var) + 0.03 * contrast + 2.0 * nonblack - 5.0 * saturated
    return float(score)


def phase_shift_between_frames(frame_a, frame_b):
    """
    用 phase correlation 粗估探头/画面整体位移。
    位移过大通常提示探头不稳或切面漂移。
    """
    a = make_small_roi(frame_a, size=128)
    b = make_small_roi(frame_b, size=128)

    try:
        shift, response = cv2.phaseCorrelate(a, b)
        dx, dy = shift
        mag = math.sqrt(dx * dx + dy * dy)

        if response < 0.01:
            mag += 5.0

        return float(mag)
    except Exception:
        return 0.0


def local_probe_jitter(frames, idx, radius=2):
    n = len(frames)
    shifts = []

    left = max(0, idx - radius)
    right = min(n - 1, idx + radius)

    for i in range(left, right):
        shifts.append(phase_shift_between_frames(frames[i], frames[i + 1]))

    if not shifts:
        return 0.0

    return float(np.median(shifts))


def build_ed_candidates(n, rr_frames, es_phase, ecg_peaks):
    """
    生成候选 ED：
    1. ECG R 峰；
    2. 从 0 开始按 RR 间隔外推的周期起点；
    3. 每个候选点附近 +/-2 帧微调。
    """
    base = set()

    for p in ecg_peaks:
        base.add(int(p))

    if rr_frames > 0:
        k = 0
        while k * rr_frames < n:
            base.add(int(k * rr_frames))
            k += 1

    if not base:
        base.add(0)

    candidates = set()
    for c in base:
        for shift in [-2, -1, 0, 1, 2]:
            cc = int(c + shift)
            es = int(round(cc + es_phase * rr_frames))
            if 0 <= cc < n and 0 <= es < n:
                candidates.add(cc)

    return sorted(candidates)


def choose_best_esed(frames, fps, rr_frames, es_phase, ecg_peaks):
    n = len(frames)

    candidates = build_ed_candidates(
        n=n,
        rr_frames=rr_frames,
        es_phase=es_phase,
        ecg_peaks=ecg_peaks
    )

    best = None

    for ed in candidates:
        es = int(round(ed + es_phase * rr_frames))

        if es < 0 or es >= n:
            continue

        ed_q = frame_quality_score(frames[ed])
        es_q = frame_quality_score(frames[es])

        ed_jitter = local_probe_jitter(frames, ed, radius=2)
        es_jitter = local_probe_jitter(frames, es, radius=2)

        # 边界安全：不要选太靠近结尾的周期
        margin = min(ed, n - 1 - es) / max(1, n - 1)

        # 如果视频明显有多周期，轻微惩罚第 0 帧附近的周期，避免探头刚落下不稳
        first_cycle_penalty = 0.0
        if n >= int(round(1.4 * rr_frames)) and ed <= 2:
            first_cycle_penalty = 2.0

        score = (
            ed_q
            + es_q
            - 0.80 * ed_jitter
            - 0.80 * es_jitter
            + 0.50 * margin
            - first_cycle_penalty
        )

        item = {
            "ed": int(ed),
            "es": int(es),
            "score": float(score),
            "ed_q": float(ed_q),
            "es_q": float(es_q),
            "ed_jitter": float(ed_jitter),
            "es_jitter": float(es_jitter),
            "margin": float(margin),
            "first_cycle_penalty": float(first_cycle_penalty)
        }

        if best is None or item["score"] > best["score"]:
            best = item

    if best is None:
        # 最坏兜底
        ed = 0
        es = int(round(es_phase * max(1, n - 1)))
        es = int(np.clip(es, 0, n - 1))
        best = {
            "ed": int(ed),
            "es": int(es),
            "score": -999.0,
            "ed_q": np.nan,
            "es_q": np.nan,
            "ed_jitter": np.nan,
            "es_jitter": np.nan,
            "margin": np.nan,
            "first_cycle_penalty": np.nan
        }

    return best


# =========================
# 可选：全帧导出
# =========================

def dump_all_frames_with_marks(frames, out_dir: Path, ed_idx: int, es_idx: int):
    out_dir.mkdir(parents=True, exist_ok=True)

    for i, frame in enumerate(frames):
        suffix = ""
        if i == ed_idx:
            suffix = "_ED"
        elif i == es_idx:
            suffix = "_ES"

        img_name = f"frame_{i:04d}{suffix}.png"
        imwrite_safe(out_dir / img_name, frame)


# =========================
# 主流程
# =========================

def main():
    parser = argparse.ArgumentParser()

    parser.add_argument(
        "--success_log",
        type=str,
        default=r"D:\echo_autolabel\success_log.csv"
    )
    parser.add_argument(
        "--accepted_root",
        type=str,
        default=r"D:\echo_project\data\pseudo_labeled_v6_final\Accepted"
    )
    parser.add_argument(
        "--summary_out",
        type=str,
        default=r"D:\echo_project\data\esed_keyframes_summary"
    )
    parser.add_argument(
        "--full_dump_out",
        type=str,
        default=r"D:\echo_project\data\esed_full_frame_dump"
    )
    parser.add_argument(
        "--max_per_view",
        type=int,
        default=30
    )
    parser.add_argument(
        "--dump_all",
        action="store_true",
        help="是否额外导出每个视频的全量帧。默认只导出 ED/ES。"
    )
    parser.add_argument(
        "--default_es_phase",
        type=float,
        default=0.40,
        help="txt 缺失或解析失败时的默认 ES 相位。"
    )

    args = parser.parse_args()

    success_log = Path(args.success_log)
    accepted_root = Path(args.accepted_root)
    summary_out = Path(args.summary_out)
    full_dump_out = Path(args.full_dump_out)

    summary_out.mkdir(parents=True, exist_ok=True)

    print("\n========================================================================")
    print("ESED关键帧提取：相位驱动 + 周期质量优选模式")
    print(f"summary_out: {summary_out}")
    print("========================================================================\n")

    if not success_log.exists():
        print(f"运行中止：找不到 success_log.csv: {success_log}")
        return

    df_log = pd.read_csv(success_log)
    df_log["New_Filename"] = df_log["New_Filename"].astype(str).str.strip()
    df_log["Original_File_Path"] = df_log["Original_File_Path"].astype(str).str.strip()
    mapping = dict(zip(df_log["New_Filename"], df_log["Original_File_Path"]))

    qc_rows = []
    total_processed = 0

    for view in ["A2C", "A3C", "A4C"]:
        view_dir = accepted_root / view

        if not view_dir.exists():
            print(f"未检测到切面文件夹，跳过: {view_dir}")
            continue

        avi_files = sorted(list(view_dir.glob("*.avi")))
        print(f"\n正在处理切面 {view}，候选视频数: {len(avi_files)}")

        view_count = 0

        for v_path in avi_files:
            if view_count >= args.max_per_view:
                print(f"{view} 已达到 max_per_view={args.max_per_view}，停止该切面。")
                break

            new_name = v_path.name
            orig_path_str = mapping.get(new_name, "")
            orig_path = Path(orig_path_str) if orig_path_str else None

            # 优先处理原始路径；如果原始路径不可用，则退回 accepted avi。
            if orig_path is not None and orig_path.exists():
                target_video = orig_path
                patient_folder = orig_path.parent
            else:
                target_video = v_path
                patient_folder = v_path.parent

            print(f"[{view} {view_count + 1}/{args.max_per_view}] {target_video.name}")

            frames, fps = read_all_frames(target_video)

            if len(frames) < 5:
                print(f"  跳过：视频无法读取或帧数过少: {target_video}")
                continue

            # 1. 从 txt 提取 ES 相位
            es_phase, txt_summary = parse_strain_txt_for_es_phase(patient_folder)

            if es_phase is None:
                es_phase = float(args.default_es_phase)
                txt_summary = "no_valid_txt_use_default"

            # 2. 从视频自身估计 RR 帧长
            rr_frames, rr_method = estimate_rr_frames_by_autocorr(frames, fps)

            # 3. ECG 弱检测，生成候选 ED
            ecg_peaks, ecg_method = detect_ecg_r_peaks(frames, fps, rr_frames)

            # 4. 多候选周期质量评分，选择 ED/ES
            best = choose_best_esed(
                frames=frames,
                fps=fps,
                rr_frames=rr_frames,
                es_phase=es_phase,
                ecg_peaks=ecg_peaks
            )

            ed_idx = int(best["ed"])
            es_idx = int(best["es"])

            # 5. 导出 ED/ES 汇总图
            stem = target_video.stem
            ed_name = f"{stem}_{view}_ED_f{ed_idx:04d}.png"
            es_name = f"{stem}_{view}_ES_f{es_idx:04d}.png"

            imwrite_safe(summary_out / ed_name, frames[ed_idx])
            imwrite_safe(summary_out / es_name, frames[es_idx])

            # 6. 可选导出全帧
            if args.dump_all:
                per_video_dir = full_dump_out / view / stem
                dump_all_frames_with_marks(
                    frames=frames,
                    out_dir=per_video_dir,
                    ed_idx=ed_idx,
                    es_idx=es_idx
                )

            qc_rows.append({
                "view": view,
                "new_filename": new_name,
                "target_video": str(target_video),
                "patient_folder": str(patient_folder),
                "fps_read_by_cv2": fps,
                "n_frames": len(frames),
                "rr_frames": rr_frames,
                "rr_method": rr_method,
                "es_phase": es_phase,
                "ed_frame": ed_idx,
                "es_frame": es_idx,
                "ecg_method": ecg_method,
                "ecg_peaks": ",".join(map(str, ecg_peaks)),
                "txt_summary": txt_summary,
                "cycle_score": best["score"],
                "ed_quality": best["ed_q"],
                "es_quality": best["es_q"],
                "ed_jitter": best["ed_jitter"],
                "es_jitter": best["es_jitter"],
                "first_cycle_penalty": best["first_cycle_penalty"],
                "ed_png": str(summary_out / ed_name),
                "es_png": str(summary_out / es_name)
            })

            view_count += 1
            total_processed += 1

    qc_df = pd.DataFrame(qc_rows)
    qc_csv = summary_out / "esed_keyframe_qc.csv"
    qc_df.to_csv(qc_csv, index=False, encoding="utf-8-sig")

    print("\n========================================================================")
    print(f"处理完成：{total_processed} 个视频")
    print(f"关键帧汇总目录: {summary_out}")
    print(f"QC表: {qc_csv}")
    print("建议先人工复核 QC 表中 cycle_score 低、ed_jitter/es_jitter 高的视频。")
    print("========================================================================")


if __name__ == "__main__":
    main()

运行方式：

bash
python dump_esed_frames_robust.py

只导出 ED/ES 汇总图。如果你还想像原脚本一样导出每个视频的全量帧：

bash
python dump_esed_frames_robust.py --dump_all

建议你后续人工复核时优先看 esed_keyframe_qc.csv 里这几列：cycle_score、ed_jitter、es_jitter、rr_method、es_phase。jitter 高的视频多半存在探头移动或切面漂移，医生画掩膜前最好单独确认。

---

掩膜绘制工具安装与使用建议

我建议你先用 Label Studio，因为你当前任务是给医生画 ED/ES 两帧的 LV blood pool 或心肌轮廓，Label Studio 上手最快，支持图像语义分割和 brush/polygon 标注；官方文档也明确支持图像标注项目和 Brush 类分割标签。(Label Studio)

方案一：Label Studio，适合快速启动

安装：

bash
conda create -n echo_mask python=3.10 -y
conda activate echo_mask
pip install label-studio
label-studio start

浏览器打开：

text
http://localhost:8080

使用流程：

1. 新建 Project。
2. 上传 esed_keyframes_summary 文件夹里的 PNG。
3. 选择 Image Segmentation 模板。
4. 标签建议设置为：
   • LV_BloodPool
   • 如果你后续要做心肌壁厚度，可再加 LV_Myocardium
5. 医生用 Brush 或 Polygon 画 ED/ES 掩膜。
6. 导出 JSON，然后你再转成 PNG mask 或 COCO 格式。

推荐的 Label Studio 标注配置可以用这个：

xml
<View>
  <Image name="image" value="$image" zoom="true" zoomControl="true" rotateControl="true"/>
  <BrushLabels name="label" toName="image">
    <Label value="LV_BloodPool" background="#ff0000"/>
    <Label value="LV_Myocardium" background="#00ff00"/>
  </BrushLabels>
</View>

如果医生更习惯点轮廓而不是涂抹，可以改用 Polygon：

xml
<View>
  <Image name="image" value="$image" zoom="true" zoomControl="true" rotateControl="true"/>
  <PolygonLabels name="label" toName="image" strokeWidth="3" pointSize="small">
    <Label value="LV_BloodPool" background="#ff0000"/>
    <Label value="LV_Myocardium" background="#00ff00"/>
  </PolygonLabels>
</View>

方案二：CVAT，适合多人协作和大规模项目

如果后面标注量变大，或者你要让多个医生分任务、做复核、做一致性检查，CVAT 更适合。CVAT 官方安装路线是 Docker Compose，本身面向图像、视频和分割标注任务。(CVAT Documentation)

安装：

bash
git clone https://github.com/cvat-ai/cvat
cd cvat
docker compose up -d

然后创建管理员账号：

bash
docker exec -it cvat_server bash -ic 'python3 ~/manage.py createsuperuser'

浏览器打开：

text
http://localhost:8080

使用流程：

1. 新建 Task。
2. 上传 ED/ES PNG。
3. 创建标签 LV_BloodPool、LV_Myocardium。
4. 用 Polygon 或 Brush 工具画掩膜。
5. 导出为 COCO、Segmentation Mask 或 CVAT XML。
6. 后续可把导出的 mask 转成训练用的二值 PNG。

---

你的当前阶段我会建议这样排优先级：

第一阶段： 用上面的脚本稳定导出 ED/ES，并人工复核 50–100 例。
第二阶段： 用 Label Studio 让医生画 LV blood pool 掩膜。
第三阶段： 用这些自有 ED/ES 掩膜训练一个 A2C/A3C/A4C 联合 U-Net 或 nnU-Net。
第四阶段： 再反过来用模型自动分割全视频，提取你前面设计的局部节段收缩特征。