SignX/doc/generate_gloss_with_frames.py

#!/usr/bin/env python3
"""
为ASLLRP_utterances_mapping.txt中的每个gloss词添加起始和结束帧号

输出格式：
{
    "utterance_id": {
        "glosses": [
            {
                "gloss": "THAT",
                "start_30fps": 9,      # 相对于utterance起始的帧号（30 FPS）
                "end_30fps": 13,
                "start_24fps": 7,      # 转换为24 FPS后的帧号
                "end_24fps": 10,
                "duration_30fps": 4,   # 持续帧数（30 FPS）
                "duration_24fps": 3,   # 持续帧数（24 FPS）
                "sign_type": "Lexical Signs"
            },
            ...
        ],
        "total_frames_30fps": 280,
        "total_frames_24fps": 224,
        "duration_seconds": 9.33
    }
}
"""

import csv
import json
from collections import defaultdict, OrderedDict
from pathlib import Path

# 目录 & 文件路径
_SCRIPT_PATH = Path(__file__).resolve()
_CWD = Path.cwd()
if (_CWD / "doc" / _SCRIPT_PATH.name).exists():
    SIGNX_DIR = _CWD
else:
    SIGNX_DIR = _SCRIPT_PATH.parents[1]

DATA_ROOT = SIGNX_DIR.parent

MAPPING_FILE = DATA_ROOT / "ASLLRP_utterances_mapping.txt"
CSV_FILE = DATA_ROOT / "asllrp_sentence_signs_2025_06_28.csv"
OUTPUT_JSON = DATA_ROOT / "ASLLRP_utterances_with_frames.json"
OUTPUT_TXT = DATA_ROOT / "ASLLRP_utterances_with_frames.txt"

FALLBACK_DIRS = [
    SIGNX_DIR,
    Path("/tmp/signx_outputs")
]


def open_with_fallback(preferred_path, mode):
    """尝试写入文件，若失败则依次使用备用目录"""
    last_path = None
    last_error = None

    candidates = [preferred_path] + [base / preferred_path.name for base in FALLBACK_DIRS]
    for candidate in candidates:
        try:
            candidate.parent.mkdir(parents=True, exist_ok=True)
            handle = candidate.open(mode, encoding='utf-8')
            if last_path is not None:
                print(f"  * 无法写入 {last_path} ({last_error}), 改写到 {candidate}")
            return handle, candidate
        except PermissionError as e:
            last_path = candidate
            last_error = e
            continue

    # 如果所有候选都失败，则抛出最后一次错误
    raise last_error

def normalize_gloss(token):
    """标准化gloss字符串，方便匹配"""
    if token is None:
        return ""
    token = token.strip()
    if token.startswith('"') and token.endswith('"') and len(token) > 1:
        token = token[1:-1]
    return token.strip().replace("\u200b", "").lower()


def load_mapping():
    """加载mapping文件"""
    mapping = {}
    with MAPPING_FILE.open('r', encoding='utf-8') as f:
        for line in f:
            line = line.strip()
            if not line or ': ' not in line:
                continue
            utterance_id, glosses = line.split(': ', 1)
            mapping[utterance_id] = glosses.split()
    return mapping

def load_csv_signs():
    """从CSV加载所有signs的详细信息"""
    signs_by_utterance = defaultdict(list)
    skipped_rows = 0

    with CSV_FILE.open('r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            try:
                utterance_video = row['Utterance video filename'].replace('.mp4', '')

                # 提取帧号信息 - 添加错误处理
                utterance_start = int(row['Start frame of the containing utterance'])
                utterance_end = int(row['End frame of the containing utterance'])
                sign_start = int(row['Start frame of the sign video'])
                sign_end = int(row['End frame of the sign video'])
            except (ValueError, KeyError) as e:
                # 跳过有问题的行
                skipped_rows += 1
                continue

            # 计算相对于utterance起始的帧号（假设CSV是30 FPS）
            relative_start_30fps = sign_start - utterance_start
            relative_end_30fps = sign_end - utterance_start

            # 转换为24 FPS
            relative_start_24fps = int(relative_start_30fps * 24 / 30)
            relative_end_24fps = int(relative_end_30fps * 24 / 30)

            sign_info = {
                'gloss': row['Main entry gloss label'],
                'start_30fps': relative_start_30fps,
                'end_30fps': relative_end_30fps,
                'start_24fps': relative_start_24fps,
                'end_24fps': relative_end_24fps,
                'duration_30fps': relative_end_30fps - relative_start_30fps,
                'duration_24fps': relative_end_24fps - relative_start_24fps,
                'sign_type': row['Sign type'],
                'utterance_start_frame': utterance_start,
                'utterance_end_frame': utterance_end,
            }

            signs_by_utterance[utterance_video].append(sign_info)

    if skipped_rows > 0:
        print(f"  警告: 跳过了 {skipped_rows} 个格式错误的CSV行")

    return signs_by_utterance

def fps_convert_30_to_24(frame_30fps):
    """将30 FPS帧号转换为24 FPS"""
    return int(frame_30fps * 24 / 30)

def align_gloss_sequence(mapping_glosses, csv_signs):
    """
    按mapping顺序匹配CSV中的gloss，自动跳过多余的CSV词条
    返回：[(mapping_gloss, csv_sign_info), ...], missing_glosses, extra_csv_signs
    """
    matched = []
    missing = []
    extras = []

    csv_idx = 0
    total_csv = len(csv_signs)

    for gloss in mapping_glosses:
        norm_gloss = normalize_gloss(gloss)
        found = None

        while csv_idx < total_csv:
            candidate = csv_signs[csv_idx]
            csv_idx += 1
            candidate_norm = normalize_gloss(candidate['gloss'])

            if candidate_norm == norm_gloss:
                found = candidate
                break
            else:
                extras.append(candidate)

        if found is None:
            missing.append(gloss)
        else:
            matched.append((gloss, found))

    if csv_idx < total_csv:
        extras.extend(csv_signs[csv_idx:])

    return matched, missing, extras

def generate_gloss_with_frames():
    """生成包含帧号的gloss数据"""
    print("加载数据...")
    mapping = load_mapping()
    csv_signs = load_csv_signs()

    result = OrderedDict()
    missing_utterances = []
    alignment_warnings = []

    print(f"处理 {len(mapping)} 个utterances...")

    for utterance_id, gloss_sequence in mapping.items():
        if utterance_id not in csv_signs:
            missing_utterances.append(utterance_id)
            continue

        signs = csv_signs[utterance_id]

        # 计算总帧数
        if signs:
            total_frames_30fps = signs[0]['utterance_end_frame'] - signs[0]['utterance_start_frame']
            total_frames_24fps = fps_convert_30_to_24(total_frames_30fps)
            duration_seconds = total_frames_30fps / 30.0
        else:
            total_frames_30fps = 0
            total_frames_24fps = 0
            duration_seconds = 0

        matched_pairs, missing_glosses, extra_signs = align_gloss_sequence(gloss_sequence, signs)

        glosses_with_frames = []
        for gloss_token, sign in matched_pairs:
            glosses_with_frames.append({
                'gloss': gloss_token,  # 保留mapping中的原始写法
                'source_gloss': sign['gloss'],
                'start_30fps': sign['start_30fps'],
                'end_30fps': sign['end_30fps'],
                'start_24fps': sign['start_24fps'],
                'end_24fps': sign['end_24fps'],
                'duration_30fps': sign['duration_30fps'],
                'duration_24fps': sign['duration_24fps'],
                'sign_type': sign['sign_type']
            })

        if missing_glosses or extra_signs:
            alignment_warnings.append({
                'utterance': utterance_id,
                'missing': missing_glosses,
                'extra_count': len(extra_signs)
            })

        result[utterance_id] = {
            'glosses': glosses_with_frames,
            'total_frames_30fps': total_frames_30fps,
            'total_frames_24fps': total_frames_24fps,
            'duration_seconds': round(duration_seconds, 2),
            'gloss_count': len(glosses_with_frames)
        }

    # 保存JSON格式
    print(f"\n保存JSON格式到 {OUTPUT_JSON}...")
    json_file, json_output_path = open_with_fallback(OUTPUT_JSON, 'w')
    with json_file as jf:
        json.dump(result, jf, indent=2, ensure_ascii=False)

    # 保存可读文本格式
    print(f"保存文本格式到 {OUTPUT_TXT}...")
    txt_file, txt_output_path = open_with_fallback(OUTPUT_TXT, 'w')
    with txt_file as tf:
        for utterance_id, data in result.items():
            gloss_strings = []
            for g in data['glosses']:
                gloss_strings.append(
                    f"{g['gloss']}[{g['start_30fps']}:{g['end_30fps']}->"
                    f"{g['start_24fps']}:{g['end_24fps']}]"
                )
            tf.write(f"{utterance_id}: {' '.join(gloss_strings)}\n")

    # 输出统计信息
    print("\n" + "="*80)
    print("处理完成!")
    print("="*80)
    print(f"总utterances: {len(mapping)}")
    print(f"成功处理: {len(result)}")
    print(f"缺失CSV数据: {len(missing_utterances)}")

    if missing_utterances:
        print(f"\n缺失的utterances (前10个): {missing_utterances[:10]}")

    if alignment_warnings:
        print(f"\n存在对齐差异的utterances: {len(alignment_warnings)}")
        for warn in alignment_warnings[:10]:
            print(f"  - {warn['utterance']}: "
                  f"missing={warn['missing'][:3]} extra_signs={warn['extra_count']}")

    # 显示一些示例
    print("\n示例数据 (前3个):")
    print("-"*80)
    for i, (utterance_id, data) in enumerate(list(result.items())[:3], 1):
        print(f"\n{i}. Utterance {utterance_id}:")
        print(f"   总帧数: {data['total_frames_30fps']} (30fps) / {data['total_frames_24fps']} (24fps)")
        print(f"   时长: {data['duration_seconds']} 秒")
        print(f"   Gloss数量: {data['gloss_count']}")
        print(f"   前5个glosses:")
        for g in data['glosses'][:5]:
            print(f"     - {g['gloss']}: "
                  f"30fps[{g['start_30fps']}:{g['end_30fps']}] "
                  f"-> 24fps[{g['start_24fps']}:{g['end_24fps']}] "
                  f"({g['duration_24fps']}帧)")

    return result, alignment_warnings, missing_utterances, json_output_path, txt_output_path

def create_compact_format(result):
    """创建紧凑格式的输出（类似原始mapping.txt）"""
    OUTPUT_COMPACT = "ASLLRP_utterances_compact_frames.txt"

    print(f"\n创建紧凑格式 {OUTPUT_COMPACT}...")

    compact_file, compact_path = open_with_fallback(DATA_ROOT / OUTPUT_COMPACT, 'w')
    with compact_file as cf:
        for utterance_id, data in result.items():
            parts = [f"{g['gloss']}|{g['start_24fps']}-{g['end_24fps']}" for g in data['glosses']]
            cf.write(f"{utterance_id}: {' '.join(parts)}\n")

    print(f"紧凑格式已保存到 {compact_path}")
    return compact_path

if __name__ == "__main__":
    print("ASLLRP Gloss帧号生成工具")
    print("="*80)

    result, alignment_warnings, missing_utterances, json_path, txt_path = generate_gloss_with_frames()
    compact_path = create_compact_format(result)

    print("\n" + "="*80)
    print("生成的文件:")
    print(f"  1. {json_path} - 完整JSON格式（包含30fps和24fps）")
    print(f"  2. {txt_path} - 可读文本格式")
    print(f"  3. {compact_path} - 紧凑格式（24fps）")
    print("="*80)