Upload folder using huggingface_hub

scripts/0_process_CCI3.py

@@ -0,0 +1,87 @@
+import json
+import os
+import random
+from tiny_shuffle import random_swap_contiguous # type: ignore
+
+
+file_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/data/part-00001-6f0afd98-d375-4d7f-8299-ac5e070bf4fc-c000.jsonl"
+save_path = f"/vol/zhaoy/ds-ocr/data/CCI3-Data/random_sample100/input.json"
+
+# 1. 读取 jsonl 文件
+data = []
+with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+    for line in f:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            data.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+
+print(f"✅ 已读取 {len(data)} 条样本")
+
+# 2. 筛选满足条件的样本
+filtered = [
+    item for item in data
+    if 100 <= item.get("meta_info", {}).get("words_count", 0) <= 10000
+]
+print(f"✅ 满足条件的样本数: {len(filtered)}")
+
+# 3. 随机抽取 500 条
+filtered = random.sample(filtered, min(200, len(filtered)))
+
+# 4. 组织格式
+processed = []
+os.makedirs("images", exist_ok=True)
+
+for i, item in enumerate(filtered, 1):
+    sample_id = f"RS{i:03d}"
+    image_path = f"images/{sample_id}.png"
+    content = item.get("text", "") or item.get("content", "")
+    content = content.replace("\n", "").replace(" ", "")  # 预处理的时候就把这些去掉
+
+    # tiny_shuffled_content, spans = random_swap_contiguous(content, n_swaps=1)
+    # shuffled_content = ''.join(random.sample(content, len(content)))
+
+    processed.append({
+        "id": sample_id,
+        "data_source": "CCI3",
+        "language": "zh",
+        "image_path": image_path,
+        "content": content,
+        "length": len(content),
+        # "tiny_shuffled_content": tiny_shuffled_content,
+        # "spans": spans,
+        # "shuffled_content": shuffled_content
+    })
+
+# 5. 保存为 JSON 文件
+with open(save_path, "w", encoding="utf-8") as f:
+    json.dump(processed, f, ensure_ascii=False, indent=2)
+
+print(f"✅ 已生成 {len(processed)} 条样本，保存至：{save_path}")
+
+
+
+
+# 6. 画 length 分布柱状图
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+
+lengths = [p["length"] for p in processed]
+bin_width = 100                           # 每 50 字一个柱
+max_len = max(lengths) if lengths else 0
+bins = list(range(0, max_len + bin_width, bin_width))
+hist, edges = np.histogram(lengths, bins=bins)
+
+plt.figure(figsize=(10, 5))
+plt.bar(edges[:-1], hist, width=bin_width, align="edge", color="skyblue", edgecolor="black")
+plt.xticks(edges[::2], rotation=45)
+plt.xlabel("Length (characters)")
+plt.ylabel("Count")
+plt.title("Random-Sample Length Distribution")
+plt.tight_layout()
+plt.savefig("/vol/zhaoy/ds-ocr/data/CCI3-Data/random_sample100/length_dist.png", dpi=300)
+print("✅ 柱状图已保存为 length_dist.png")

scripts/0_process_CCI3_avg.py

@@ -0,0 +1,142 @@
+import json
+import os
+import random
+from tiny_shuffle import random_swap_contiguous # type: ignore
+from collections import defaultdict # <--- 导入 defaultdict 用于分桶
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+
+# --- 路径定义 ---
+base_dir = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_5k-10k_sample100_interval500_per10"
+file_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/data/part-00001-6f0afd98-d375-4d7f-8299-ac5e070bf4fc-c000.jsonl"
+save_path = f"{base_dir}/meta.json"
+plot_save_path = f"{base_dir}/length_dist.png"
+image_save_dir = f"/images"
+
+# 1. 读取 jsonl 文件 (不变)
+data = []
+with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+    for line in f:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            data.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+
+print(f"✅ 已读取 {len(data)} 条样本")
+
+# 2. (***修改***) 筛选满足条件的样本
+#    不再使用 meta_info, 而是直接计算真实长度来进行筛选
+print("🚀 开始按 'content' 真实字符长度进行预筛选...")
+filtered_by_char_length = []
+for item in data:
+    # 使用与步骤 3 中完全一致的 content 清洗逻辑
+    content = item.get("text", "") or item.get("content", "")
+    content = content.replace("\n", "").replace(" ", "")
+    length = len(content)
+    
+    # 在这里进行你想要的真实长度过滤 (例如，你希望过滤掉超过 10000 个字符的)
+    # 注意：如果你这里设置了 10000，你就永远不会得到 [24500 - 24999] 的桶
+    # 假设你真正的意思是 100 到 100000
+    if 5000 <= length <= 10000:  # <--- 在这里设置你想要的真实字符长度范围
+        # 将计算好的 length 存储起来，避免第 3 步重复计算
+        item['_true_length'] = length 
+        filtered_by_char_length.append(item)
+        
+print(f"✅ 满足 '真实字符长度' 条件的样本数: {len(filtered_by_char_length)}")
+
+
+# 3. (***修改***) 按 'content' 字符长度进行平衡采样
+print("🚀 开始按 'content' 字符长度进行平衡采样...")
+bin_size = 500       # 采样间隔 (每 500 个字符一个区间)
+samples_per_bin = 10   # 每个区间抽 10 条
+
+# 3.1. 分桶
+binned_data = defaultdict(list)
+# 注意：这里要遍历上一步筛选过的 filtered_by_char_length
+for item in filtered_by_char_length: 
+    
+    # 直接使用上一步计算好的长度
+    length = item['_true_length']
+    
+    # 计算所属的桶 (bin)
+    bin_key = length // bin_size
+    binned_data[bin_key].append(item)
+
+# 3.2. 从每个桶中采样
+balanced_samples = []
+print(f"  -> 采样间隔: {bin_size} 字符, 每个区间最多: {samples_per_bin} 条")
+for bin_key in sorted(binned_data.keys()):
+    items_in_bin = binned_data[bin_key]
+    n_to_sample = min(samples_per_bin, len(items_in_bin))
+    sampled_items = random.sample(items_in_bin, n_to_sample)
+    balanced_samples.extend(sampled_items)
+    
+    min_len = bin_key * bin_size
+    max_len = (bin_key + 1) * bin_size - 1
+    print(f"  -> 区间 [{min_len:>5d} - {max_len:>5d}]: 找到 {len(items_in_bin):>4} 条, 抽取 {n_to_sample} 条")
+
+# 3.3. 替换原来的 'filtered' 变量
+filtered = balanced_samples
+print(f"✅ 平衡采样后总样本数: {len(filtered)}")
+
+
+# 4. 组织格式 (***修改***)
+processed = []
+os.makedirs(image_save_dir, exist_ok=True) 
+
+for i, item in enumerate(filtered, 1):
+    sample_id = f"RS{i:03d}"
+    image_path = f"{image_save_dir}/{sample_id}.png" 
+    
+    # 再次清理（或者直接使用上一步的清理结果，但为保险起见，再次清理也无妨）
+    content = item.get("text", "") or item.get("content", "")
+    content = content.replace("\n", "").replace(" ", "") 
+
+    processed.append({
+        "id": sample_id,
+        "data_source": "CCI3",
+        "language": "zh",
+        "image_path": image_path,
+        "content": content,
+        "length": item['_true_length'], # <--- 直接使用缓存的长度
+    })
+
+
+# 5. 保存为 JSON 文件 (不变)
+os.makedirs(os.path.dirname(save_path), exist_ok=True)
+with open(save_path, "w", encoding="utf-8") as f:
+    json.dump(processed, f, ensure_ascii=False, indent=2)
+
+print(f"✅ 已生成 {len(processed)} 条样本，保存至：{save_path}")
+
+
+# 6. 画 length 分布柱状图 (基本不变)
+lengths = [p["length"] for p in processed]
+
+if not lengths:
+    print("⚠️ 采样结果为空，无法绘制柱状图。")
+else:
+    # 注意：这里的 bin_width 是绘图的柱宽，可以和采样的 bin_size (500) 不一样
+    # 使用 100 作为柱宽，可以更精细地看清分布
+    bin_width = bin_size                       
+    max_len = max(lengths)
+    bins = list(range(0, max_len + bin_width, bin_width))
+    hist, edges = np.histogram(lengths, bins=bins)
+
+    plt.figure(figsize=(10, 5))
+    plt.bar(edges[:-1], hist, width=bin_width, align="edge", color="skyblue", edgecolor="black")
+    
+    # 动态调整 x 轴刻度，避免过于密集
+    tick_step = max(1, len(edges) // 20) # 保持最多约 20 个刻度
+    plt.xticks(edges[::tick_step], rotation=45) 
+    
+    plt.xlabel("Length (characters)")
+    plt.ylabel("Count")
+    plt.title(f"Balanced-Sample Length Distribution (Total: {len(lengths)})")
+    plt.tight_layout()
+    plt.savefig(plot_save_path, dpi=300) # 使用变量
+    print(f"✅ 柱状图已保存为 {plot_save_path}")

scripts/0_process_stories.py

@@ -0,0 +1,97 @@
+import json
+import os
+import random
+import re
+from tiny_shuffle import random_swap_contiguous # type: ignore
+
+def shuffle_words_and_punct(text: str) -> str:
+    """
+    随机打乱英文文本中的单词和标点顺序。
+    保留标点作为独立token。
+    """
+    # 用正则提取单词和标点
+    tokens = re.findall(r"[A-Za-z0-9]+|[^\w\s]", text)
+    if not tokens:
+        return text
+
+    shuffled = tokens[:]
+    random.shuffle(shuffled)
+
+    # 重新拼接成句子
+    # 逻辑：若下一个是标点，则不加空格；否则加空格
+    result = ""
+    for i, tok in enumerate(shuffled):
+        if i > 0 and not re.match(r"[^\w\s]", tok):  # 不是标点才加空格
+            result += " "
+        result += tok
+
+    return result
+
+file_path = "/vol/zhaoy/ds-ocr/data/Stories_en/data/Children-Stories-0-Final.json"
+save_path = f"/vol/zhaoy/ds-ocr/data/Stories_en/sample200_len0.8-1.2k/input.json"
+
+# 1. 读取 jsonl 文件
+with open(file_path, "r", encoding="utf-8") as f:
+    data_o = json.load(f)
+
+    new_data = []
+    i = 0
+    while i < len(data_o):
+        # 若只剩最后一条，直接保存
+        if i == len(data_o) - 1:
+            item = {
+                "text": data_o[i]["text"],
+                "text_token_length": len(data_o[i]["text"].split())
+            }
+            new_data.append(item)
+            break
+
+        # 合并相邻两条
+        text1 = data_o[i]["text"].strip()
+        text2 = data_o[i + 1]["text"].strip()
+        merged_text = text1 + " " + text2
+
+        item = {
+            "text": merged_text,
+            "text_length": len(merged_text.split())
+        }
+        new_data.append(item)
+        i += 2  # 跳过两条
+
+# 2. 筛选满足条件的样本
+filtered = [
+    item for item in new_data
+    if 800 <= item["text_length"] <= 1200
+]
+print(f"✅ 满足条件的样本数: {len(filtered)}")
+
+# 3. 随机抽取 x 条
+sampled = random.sample(filtered, min(10, len(filtered)))
+
+# 4. 组织格式
+processed = []
+os.makedirs("images", exist_ok=True)
+
+for i, item in enumerate(sampled, 1):
+    sample_id = f"RS{i:03d}"
+    image_path = f"images/{sample_id}.png"
+    content = item.get("text", "") or item.get("content", "")
+    content = content.replace("\n", "")
+
+    tiny_shuffled_content, spans = random_swap_contiguous(content, n_swaps=1)
+    shuffled_content = shuffle_words_and_punct(content)
+
+    processed.append({
+        "id": sample_id,
+        "image_path": image_path,
+        "content": content,
+        "tiny_shuffled_content": tiny_shuffled_content,
+        "spans": spans,
+        "shuffled_content": shuffled_content
+    })
+
+# 5. 保存为 JSON 文件
+with open(save_path, "w", encoding="utf-8") as f:
+    json.dump(processed, f, ensure_ascii=False, indent=2)
+
+print(f"✅ 已生成 {len(processed)} 条样本，保存至：{save_path}")

scripts/1_render_images.py

@@ -0,0 +1,95 @@
+# 做pilot study的时候用的渲染代码
+
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+import json, os
+
+def read_jsonl(file_path):
+    """
+    读取 JSONL 文件并返回解析后的数据列表。
+    
+    :param file_path: JSONL 文件的路径
+    :return: 包含所有 JSON 对象的列表
+    """
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            data.append(json.loads(line.strip()))
+    return data
+
+# ========================
+# 参数配置
+# ========================
+
+# 数据路径
+json_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10/test.jsonl"
+data = read_jsonl(json_path)
+
+# 输出目录
+output_root = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10"
+
+# 三个版本及对应字段
+versions = {
+    "normal": "content",
+    "shuffled": "shuffled_content",
+    "tiny_shuffled": "tiny_shuffled_content",
+}
+
+# 字体路径与大小
+font_path = "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"
+font_size = 64
+font = ImageFont.truetype(font_path, font_size)
+
+# 每行最大字符数
+max_chars_per_line = 40  # 中文
+# max_chars_per_line = 100  # 英文
+
+# ========================
+# 主流程
+# ========================
+
+
+
+for version_name, field in versions.items():
+    # 创建输出文件夹
+    image_root = os.path.join(output_root, version_name, "images")
+    os.makedirs(image_root, exist_ok=True)
+
+    print(f"\n🖋 正在生成 {version_name} 版本的图片到 {image_root} ...")
+
+    for item in data:
+        text = item.get(field, "")
+        if not text:
+            print(f"⚠️ 跳过 {item['id']}：字段 {field} 为空。")
+            continue
+
+        # 自动换行
+        wrapped_text = textwrap.fill(text, width=max_chars_per_line)
+
+        # 计算文本尺寸
+        dummy_img = Image.new("RGB", (10, 10))
+        draw = ImageDraw.Draw(dummy_img)
+        bbox = draw.multiline_textbbox((0, 0), wrapped_text, font=font, spacing=10)
+        text_w, text_h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        # 加 padding
+        padding = 50
+        img_w, img_h = text_w + 2 * padding, text_h + 2 * padding
+
+        # 创建并绘制图片
+        img = Image.new("RGB", (img_w, img_h), (255, 255, 255))
+        draw = ImageDraw.Draw(img)
+        draw.multiline_text(
+            (padding, padding),
+            wrapped_text,
+            font=font,
+            fill=(0, 0, 0),
+            spacing=10,
+        )
+
+        # 保存图片
+        image_path = os.path.join(image_root, f"{item['id']}.png")
+        img.save(image_path)
+        print(f"✅ {version_name} - 已生成 {item['id']} ({img_w}x{img_h})")
+
+print("\n🎨 所有版本图片生成完毕！")

scripts/1_render_images_v2.py

@@ -0,0 +1,55 @@
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+
+def text_to_image(text, output_path="output.png",
+                  font_path=None, font_size=24,
+                  max_width=800, padding=40,
+                  bg_color="white", text_color="black",
+                  line_spacing=1.0):
+    """
+    将文本渲染成图片（白底黑字）
+    自动根据字体行高调整行间距
+    适合论文插图或说明展示
+    """
+    # 字体路径设置
+    if font_path is None:
+        # Windows 可改为 "C:/Windows/Fonts/simhei.ttf"
+        font_path = "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"
+    font = ImageFont.truetype(font_path, font_size)
+
+    # 自动换行
+    lines = []
+    for paragraph in text.split("\n"):
+        # 粗略估算一行能放多少字
+        wrap_width = int(max_width / font_size * 1.8)
+        wrapped = textwrap.wrap(paragraph, width=wrap_width) or [" "]
+        lines.extend(wrapped)
+
+    # 获取字体的行高（更精确）
+    ascent, descent = font.getmetrics()
+    line_height = int((ascent + descent) * line_spacing)
+
+    # 计算图片大小
+    img_height = line_height * len(lines) + 2 * padding
+    img_width = max_width + 2 * padding
+
+    # 创建图片
+    img = Image.new("RGB", (img_width, img_height), color=bg_color)
+    draw = ImageDraw.Draw(img)
+
+    # 绘制文字
+    y = padding
+    for line in lines:
+        draw.text((padding, y), line, fill=text_color, font=font)
+        y += line_height
+
+    img.save(output_path)
+    print(f"✅ 图片已保存到: {output_path}")
+
+
+# 示例用法
+if __name__ == "__main__":
+    sample_text = """这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。v
+可以包含多行内容，用于渲染成白底黑字的论文插图风格。
+支持中文和英文混排 English example line."""
+    text_to_image(sample_text, "/vol/text_image.png", font_size=28)

scripts/1_render_images_v3.py

@@ -0,0 +1,201 @@
+from PIL import Image, ImageDraw, ImageFont
+import re, os, json
+from tqdm import tqdm
+
+def read_jsonl(file_path):
+    """
+    读取 JSONL 文件并返回解析后的数据列表。
+    
+    :param file_path: JSONL 文件的路径
+    :return: 包含所有 JSON 对象的列表
+    """
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            data.append(json.loads(line.strip()))
+    return data
+
+def save_jsonl(data, file_path):
+    """
+    将数据保存为 JSONL 文件。
+    
+    :param data: 要保存的数据（Python 对象的列表）
+    :param file_path: 保存的 JSONL 文件路径
+    """
+    with open(file_path, 'w', encoding='utf-8') as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+def split_tokens_for_wrapping(text):
+    """
+    将文本切分为用于换行的 tokens：
+    - 英文单词/数字/标点尽量按空格分块
+    - 连续中文或其它无空格脚本按字符切分
+    返回 token 列表（保持原始顺序）
+    """
+    tokens = []
+    # 使用正则把英文单词/空格段和非空格段分开
+    # 这个策略：先按空格分段，然后对每段若含中文则拆成单字符，否则保留整段
+    for part in re.split(r'(\s+)', text):
+        if part == "":
+            continue
+        if part.isspace():
+            tokens.append(part)  # 保留空格作为独立 token（便于保持空格）
+            continue
+        # 如果包含 CJK 文字，则把它拆成单字符（更安全）
+        if re.search(r'[\u4e00-\u9fff]', part):
+            tokens.extend(list(part))
+        else:
+            # 非中文段按单词/标点继续拆分（保持单词完整）
+            # 但如果单词非常长，也允许按字符拆分（后面处理）
+            tokens.append(part)
+    return tokens
+
+def wrap_text_pixel(draw, text, font, max_width):
+    """
+    基于像素宽度把 text 换行，返回行列表。
+    draw: ImageDraw.Draw 实例（用于测量）
+    """
+    tokens = split_tokens_for_wrapping(text)
+    lines = []
+    cur_line = ""
+    for token in tokens:
+        # 试拼接 token（注意保留空格）
+        candidate = cur_line + token
+        # 使用 textbbox 更准确（返回 bbox 四元组）
+        bbox = draw.textbbox((0,0), candidate, font=font)
+        w = bbox[2] - bbox[0]
+        if w <= max_width:
+            cur_line = candidate
+        else:
+            if cur_line:  # 把当前行推入，token 放到下一行
+                lines.append(cur_line.rstrip())  # 去掉尾部多余空格
+                # 如果 token 自己也超长（单词无空格且宽度>max_width），按字符拆分
+                token_bbox = draw.textbbox((0,0), token, font=font)
+                token_w = token_bbox[2] - token_bbox[0]
+                if token_w > max_width and len(token) > 1:
+                    # 按字符贪心拆分
+                    sub = ""
+                    for ch in token:
+                        cand2 = sub + ch
+                        if draw.textbbox((0,0), cand2, font=font)[2] - draw.textbbox((0,0), cand2, font=font)[0] <= max_width:
+                            sub = cand2
+                        else:
+                            if sub:
+                                lines.append(sub)
+                            sub = ch
+                    if sub:
+                        cur_line = sub
+                    else:
+                        cur_line = ""
+                else:
+                    # token 能单独放下一行
+                    cur_line = token.lstrip()  # 去掉起始空格
+            else:
+                # cur_line 为空但 token 仍超过 max_width（非常长的单词/无空格序列）
+                # 按字符拆分
+                sub = ""
+                for ch in token:
+                    cand2 = sub + ch
+                    if draw.textbbox((0,0), cand2, font=font)[2] - draw.textbbox((0,0), cand2, font=font)[0] <= max_width:
+                        sub = cand2
+                    else:
+                        if sub:
+                            lines.append(sub)
+                        sub = ch
+                if sub:
+                    cur_line = sub
+                else:
+                    cur_line = ""
+    if cur_line:
+        lines.append(cur_line.rstrip())
+    return lines
+
+def text_to_image_precise(text, output_path="output.png",
+                          font_path=None, font_size=24,
+                          max_width=1600, padding=40,
+                          bg_color="white", text_color="black",
+                          line_spacing=1.0, min_width=200):
+    """
+    基于像素测量的文本渲染，避免超出边距。
+    """
+    # 字体
+    if font_path is None:
+        font_path = "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"
+    font = ImageFont.truetype(font_path, font_size)
+
+    # 先创建临时画布用于测量
+    tmp_img = Image.new("RGB", (10, 10), color=bg_color)
+    draw = ImageDraw.Draw(tmp_img)
+
+    # 对每一段（以换行分隔）分别换行，然后合并成最终行列表
+    final_lines = []
+    for paragraph in text.split("\n"):
+        paragraph = paragraph.rstrip("\n")
+        if paragraph == "":
+            final_lines.append("")  # 保持空行
+            continue
+        wrapped = wrap_text_pixel(draw, paragraph, font, max_width)
+        final_lines.extend(wrapped)
+
+    # 计算实际内容宽度（取最长行的像素宽度）
+    max_line_w = 0
+    for line in final_lines:
+        bbox = draw.textbbox((0,0), line, font=font)
+        w = bbox[2] - bbox[0]
+        if w > max_line_w:
+            max_line_w = w
+
+    content_width = max(min_width, max_line_w)
+    img_width = int(content_width + 2 * padding)
+
+    # 字高与行距
+    ascent, descent = font.getmetrics()
+    line_height = int((ascent + descent) * line_spacing)
+
+    img_height = line_height * len(final_lines) + 2 * padding
+
+    # 创建最终图片并绘制
+    img = Image.new("RGB", (img_width, img_height), color=bg_color)
+    draw_final = ImageDraw.Draw(img)
+
+    y = padding
+    for line in final_lines:
+        draw_final.text((padding, y), line, fill=text_color, font=font)
+        y += line_height
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    img.save(output_path)
+    print(f"✅ 图片已保存到: {output_path} (size: {img_width}x{img_height})")
+    return img  # 方便调试时返回 PIL.Image 对象
+
+
+
+
+# 示例用法
+if __name__ == "__main__":
+
+    mapping = {
+        "形近字替换": "similar_char",
+        "音近/同音字替换": "phonetic_char",
+        "语序颠倒": "word_order",
+        "字符增衍": "char_insertion",
+        "字符缺失": "char_deletion"
+    }
+    image_root = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_5k-10k_sample100_interval500_per10_last_mode/"
+    meta_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_5k-10k_sample100_interval500_per10_last_mode/output_processed_last-mode.jsonl"
+    data = read_jsonl(meta_path)
+    for item in tqdm(data):
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                text = extent["edited"]
+                ned = extent["NED"]
+                image_path = os.path.join(image_root, "images", mapping[dim], os.path.basename(item["image_path"]).replace(".png", f"_ned-{ned}.png"))
+                extent["image_path"] = os.path.join("images", mapping[dim], os.path.basename(item["image_path"]).replace(".png", f"_ned-{ned}.png"))
+                text_to_image_precise(text, image_path, font_size=28)
+
+    save_jsonl(data, meta_path)  # 随便覆盖，只是加了个["image_path"]
+#     sample_text = """这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。这是一段示例文本。v
+# 可以包含多行内容，用于渲染成白底黑字的论文插图风格。
+# 支持中文和英文混排 English example line."""
+#     text_to_image_precise(sample_text, "/vol/text_image.png", font_size=28)

scripts/1_render_images_v3_concurrent.py

@@ -0,0 +1,235 @@
+from PIL import Image, ImageDraw, ImageFont
+import re, os, json
+from tqdm import tqdm
+import concurrent
+from concurrent.futures import ThreadPoolExecutor
+import copy
+
+def read_jsonl(file_path):
+    """
+    读取 JSONL 文件并返回解析后的数据列表。
+    
+    :param file_path: JSONL 文件的路径
+    :return: 包含所有 JSON 对象的列表
+    """
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            data.append(json.loads(line.strip()))
+    return data
+
+def save_jsonl(data, file_path):
+    """
+    将数据保存为 JSONL 文件。
+    
+    :param data: 要保存的数据（Python 对象的列表）
+    :param file_path: 保存的 JSONL 文件路径
+    """
+    with open(file_path, 'w', encoding='utf-8') as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+def split_tokens_for_wrapping(text):
+    """
+    将文本切分为用于换行的 tokens：
+    - 英文单词/数字/标点尽量按空格分块
+    - 连续中文或其它无空格脚本按字符切分
+    返回 token 列表（保持原始顺序）
+    """
+    tokens = []
+    # 使用正则把英文单词/空格段和非空格段分开
+    # 这个策略：先按空格分段，然后对每段若含中文则拆成单字符，否则保留整段
+    for part in re.split(r'(\s+)', text):
+        if part == "":
+            continue
+        if part.isspace():
+            tokens.append(part)  # 保留空格作为独立 token（便于保持空格）
+            continue
+        # 如果包含 CJK 文字，则把它拆成单字符（更安全）
+        if re.search(r'[\u4e00-\u9fff]', part):
+            tokens.extend(list(part))
+        else:
+            # 非中文段按单词/标点继续拆分（保持单词完整）
+            # 但如果单词非常长，也允许按字符拆分（后面处理）
+            tokens.append(part)
+    return tokens
+
+def wrap_text_pixel(draw, text, font, max_width):
+    """
+    基于像素宽度把 text 换行，返回行列表。
+    draw: ImageDraw.Draw 实例（用于测量）
+    """
+    tokens = split_tokens_for_wrapping(text)
+    lines = []
+    cur_line = ""
+    for token in tokens:
+        # 试拼接 token（注意保留空格）
+        candidate = cur_line + token
+        # 使用 textbbox 更准确（返回 bbox 四元组）
+        bbox = draw.textbbox((0,0), candidate, font=font)
+        w = bbox[2] - bbox[0]
+        if w <= max_width:
+            cur_line = candidate
+        else:
+            if cur_line:  # 把当前行推入，token 放到下一行
+                lines.append(cur_line.rstrip())  # 去掉尾部多余空格
+                # 如果 token 自己也超长（单词无空格且宽度>max_width），按字符拆分
+                token_bbox = draw.textbbox((0,0), token, font=font)
+                token_w = token_bbox[2] - token_bbox[0]
+                if token_w > max_width and len(token) > 1:
+                    # 按字符贪心拆分
+                    sub = ""
+                    for ch in token:
+                        cand2 = sub + ch
+                        if draw.textbbox((0,0), cand2, font=font)[2] - draw.textbbox((0,0), cand2, font=font)[0] <= max_width:
+                            sub = cand2
+                        else:
+                            if sub:
+                                lines.append(sub)
+                            sub = ch
+                    if sub:
+                        cur_line = sub
+                    else:
+                        cur_line = ""
+                else:
+                    # token 能单独放下一行
+                    cur_line = token.lstrip()  # 去掉起始空格
+            else:
+                # cur_line 为空但 token 仍超过 max_width（非常长的单词/无空格序列）
+                # 按字符拆分
+                sub = ""
+                for ch in token:
+                    cand2 = sub + ch
+                    if draw.textbbox((0,0), cand2, font=font)[2] - draw.textbbox((0,0), cand2, font=font)[0] <= max_width:
+                        sub = cand2
+                    else:
+                        if sub:
+                            lines.append(sub)
+                        sub = ch
+                if sub:
+                    cur_line = sub
+                else:
+                    cur_line = ""
+    if cur_line:
+        lines.append(cur_line.rstrip())
+    return lines
+
+def text_to_image_precise(text, output_path="output.png",
+                          font_path=None, font_size=24,
+                          max_width=1600, padding=40,
+                          bg_color="white", text_color="black",
+                          line_spacing=1.0, min_width=200):
+    """
+    基于像素测量的文本渲染，避免超出边距。
+    """
+    # 字体
+    if font_path is None:
+        font_path = "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"
+    font = ImageFont.truetype(font_path, font_size)
+
+    # 先创建临时画布用于测量
+    tmp_img = Image.new("RGB", (10, 10), color=bg_color)
+    draw = ImageDraw.Draw(tmp_img)
+
+    # 对每一段（以换行分隔）分别换行，然后合并成最终行列表
+    final_lines = []
+    for paragraph in text.split("\n"):
+        paragraph = paragraph.rstrip("\n")
+        if paragraph == "":
+            final_lines.append("")  # 保持空行
+            continue
+        wrapped = wrap_text_pixel(draw, paragraph, font, max_width)
+        final_lines.extend(wrapped)
+
+    # 计算实际内容宽度（取最长行的像素宽度）
+    max_line_w = 0
+    for line in final_lines:
+        bbox = draw.textbbox((0,0), line, font=font)
+        w = bbox[2] - bbox[0]
+        if w > max_line_w:
+            max_line_w = w
+
+    content_width = max(min_width, max_line_w)
+    img_width = int(content_width + 2 * padding)
+
+    # 字高与行距
+    ascent, descent = font.getmetrics()
+    line_height = int((ascent + descent) * line_spacing)
+
+    img_height = line_height * len(final_lines) + 2 * padding
+
+    # 创建最终图片并绘制
+    img = Image.new("RGB", (img_width, img_height), color=bg_color)
+    draw_final = ImageDraw.Draw(img)
+
+    y = padding
+    for line in final_lines:
+        draw_final.text((padding, y), line, fill=text_color, font=font)
+        y += line_height
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    img.save(output_path)
+    print(f"✅ 图片已保存到: {output_path} (size: {img_width}x{img_height})")
+    return img  # 方便调试时返回 PIL.Image 对象
+
+
+def process_render_item(item, mapping, image_root):
+    """
+    负责渲染一个 item 下所有 extent 对应的图片。
+    会修改 item（添加 extent["image_path"]）
+    """
+    for dim, v in item["rewrite"].items():
+        for extent in v["extents"]:
+            text = extent["edited"]
+            ned = extent["NED"]
+
+            # 生成输出图片路径
+            filename = os.path.basename(item["image_path"]).replace(
+                ".png", f"_ned-{ned}.png"
+            )
+            rel_path = os.path.join("images", mapping[dim], filename)
+            abs_path = os.path.join(image_root, rel_path)
+
+            # 创建文件夹
+            os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+
+            # 保存相对路径
+            extent["image_path"] = rel_path
+
+            # 渲染文本到图像
+            text_to_image_precise(text, abs_path, font_size=28)
+
+    return item  # 返回已更新的 item
+
+# 示例用法
+if __name__ == "__main__":
+    # 不是，tmd怎么多线程比单线程还慢...
+    max_workers = 50
+
+    mapping = {
+        "形近字替换": "similar_char",
+        "音近/同音字替换": "phonetic_char",
+        "语序颠倒": "word_order",
+        "字符增衍": "char_insertion",
+        "字符缺失": "char_deletion"
+    }
+
+    image_root = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10_last-mode/"
+    meta_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10_last-mode/output_processed_last-mode.jsonl"
+
+    data = read_jsonl(meta_path)
+
+    # 启动多线程渲染
+    updated_items = []
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = [
+            executor.submit(process_render_item, item, mapping, image_root)
+            for item in data
+        ]
+
+        for future in tqdm(concurrent.futures.as_completed(futures), total=len(futures)):
+            updated_items.append(copy.deepcopy(future.result()))
+
+    # 保存更新后的 JSONL（只写一次）
+    save_jsonl(updated_items, meta_path)
+    print("🚀 全部渲染完成并写入 JSON!")

scripts/3_calu_metric_v1.py

@@ -0,0 +1,68 @@
+import json
+import Levenshtein
+
+def compute_edit_distance(pred: str, gt: str) -> float:
+    """
+    计算两个字符串的归一化编辑距离 (Normalized Edit Distance, NED)
+    值域为 [0, 1]，越小表示越相似。
+    """
+    pred = pred.replace("\n", "").replace(" ", "")
+    gt = gt.replace("\n", "").replace(" ", "")
+    if not pred and not gt:
+        return 0.0
+    dist = Levenshtein.distance(pred, gt)
+    return round(dist / max(len(pred), len(gt)), 4)
+
+
+def compute_accuracy(json_path: str):
+    """从 JSON 文件批量计算平均 NED 及每条样本的编辑距离"""
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    total_ned = 0
+    sample_accuracies = []
+
+    for sample in data:
+        # Ground truth 选择逻辑
+        if "normal" in json_path:
+            gt = sample.get("content", "")
+        elif "tiny_shuffled" in json_path:
+            gt = sample.get("tiny_shuffled_content", "")
+        elif "shuffled" in json_path:
+            gt = sample.get("shuffled_content", "")
+        else:
+            raise ValueError("无法确定使用哪个字段作为 ground truth")
+
+        pred = sample.get("ocr", "")
+        ned = compute_edit_distance(pred, gt)
+        total_ned += ned
+
+        sample_accuracies.append({
+            "id": sample["id"],
+            "image_path": sample["image_path"],
+            "content": gt,
+            "ocr": sample["ocr"],
+            "NED": ned
+        })
+
+    overall_ned = round(total_ned / len(data), 4)
+    print(f"共 {len(data)} 条样本, 平均 NED = {overall_ned}")
+
+    return overall_ned, sample_accuracies
+
+
+if __name__ == "__main__":
+
+    # json_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/sample200_len1.0-1.2k/tiny_shuffled/input_small_ocr.json"
+    # overall_ned, sample_accuracies = compute_accuracy(json_path)
+    # # 保存每条样本的编辑距离
+    # out_path = json_path.replace(".json", "_acc.json")
+    # with open(out_path, "w", encoding="utf-8") as f:
+    #     json.dump(sample_accuracies, f, ensure_ascii=False, indent=2)
+    # print(f"结果已保存至：{out_path}")
+
+
+    origin = "四月飞雪《四月飞雪》是四月菲雪创作的网络小说，发表于起点网。作品简介大千世界，两亿年前究竟发生了什么，在我们身边，好似缺少着什么，，一个生活在这个世界的小孩，究竟经历了什么，一步步走上了永无止境的通天大道。。接下来就让我们一起见证。。。。。"
+    mod = "四月飞雪《四月飞雪雪》是四月菲雪作创作的网络小说，发表于起点网。作作品简大简介世大千世界，两两亿年前究竟发竟发什生了什么，在我们身身边，好似缺什少着什么，，一个生活活在这个世世小界的小孩，经究竟经历了什么，一步步步上走上了永止无止天境的通天大道。。接下来就让我们一起见见证。。。。。"
+    ned = compute_edit_distance(origin, mod)
+    print(ned)

scripts/3_calu_metric_v2.py

@@ -0,0 +1,197 @@
+import json
+import Levenshtein
+from fit_2d import plot_density_ned
+from fit_3d import fit_and_plot_3d
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+def read_jsonl(file_path):
+    """
+    读取 JSONL 文件并返回解析后的数据列表。
+    
+    :param file_path: JSONL 文件的路径
+    :return: 包含所有 JSON 对象的列表
+    """
+    data = []
+    with open(file_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            data.append(json.loads(line.strip()))
+    return data
+
+def save_jsonl(data, file_path):
+    """
+    将数据保存为 JSONL 文件。
+    
+    :param data: 要保存的数据（Python 对象的列表）
+    :param file_path: 保存的 JSONL 文件路径
+    """
+    with open(file_path, 'w', encoding='utf-8') as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+
+def compute_edit_distance(pred: str, gt: str) -> float:
+    """
+    计算两个字符串的归一化编辑距离 (Normalized Edit Distance, NED)
+    值域为 [0, 1]，越小表示越相似。
+    """
+    pred = pred.replace("\n", "").replace(" ", "")
+    gt = gt.replace("\n", "").replace(" ", "")
+    if not pred and not gt:
+        return 0.0
+    dist = Levenshtein.distance(pred, gt)
+    return round(dist / max(len(pred), len(gt)), 4)
+
+
+def compute_accuracy(json_path: str):
+    """从 JSON 文件批量计算平均 NED 及每条样本的编辑距离"""
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+
+    total_ned = 0
+    sample_accuracies = []
+
+    for sample in data:
+        # Ground truth 选择逻辑
+        if "normal" in json_path:
+            gt = sample.get("content", "")
+        elif "tiny_shuffled" in json_path:
+            gt = sample.get("tiny_shuffled_content", "")
+        elif "shuffled" in json_path:
+            gt = sample.get("shuffled_content", "")
+        else:
+            raise ValueError("无法确定使用哪个字段作为 ground truth")
+
+        pred = sample.get("ocr", "")
+        ned = compute_edit_distance(pred, gt)
+        total_ned += ned
+
+        sample_accuracies.append({
+            "id": sample["id"],
+            "image_path": sample["image_path"],
+            "content": gt,
+            "ocr": sample["ocr"],
+            "NED": ned
+        })
+
+    overall_ned = round(total_ned / len(data), 4)
+    print(f"共 {len(data)} 条样本, 平均 NED = {overall_ned}")
+
+    return overall_ned, sample_accuracies
+
+
+def plot_length_ned_bar(data, output_path="length_ned_bar.png",
+                        length_bin_width=500, ned_bin_width=0.05):
+    """
+    用柱状图显示 item['length'] 与 extent['NED'] 的频率
+
+    参数:
+        data: 原始数据列表
+        output_path: 图片保存路径
+        length_bin_width: 文字长度的柱宽
+        ned_bin_width: NED的柱宽
+    """
+    # 提取 length 和 NED
+    length_vals = []
+    ned_vals = []
+    for item in data:
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                length_vals.append(len(extent["edited"]))
+                ned_vals.append(extent["NED"])
+
+    length_vals = np.array(length_vals)
+    ned_vals = np.array(ned_vals)
+
+    if len(length_vals) == 0:
+        print("⚠️ 数据为空，未生成图像。")
+        return
+
+    # --- 文字长度柱状图 ---
+    length_bins = np.arange(min(length_vals), max(length_vals) + length_bin_width, length_bin_width)
+    plt.figure(figsize=(8, 4))
+    plt.hist(length_vals, bins=length_bins, color='skyblue', edgecolor='black')
+    plt.xlabel("Text Length")
+    plt.ylabel("Frequency")
+    plt.title("Frequency of Text Length")
+    plt.xticks(length_bins)
+    plt.tight_layout()
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    plt.savefig(output_path.replace(".png", "_length.png"), dpi=300)
+    plt.close()
+
+    # --- NED柱状图 ---
+    ned_bins = np.arange(0, 1 + ned_bin_width, ned_bin_width)
+    plt.figure(figsize=(8, 4))
+    plt.hist(ned_vals, bins=ned_bins, color='salmon', edgecolor='black')
+    plt.xlabel("NED")
+    plt.ylabel("Frequency")
+    plt.title("Frequency of NED")
+    plt.xticks(ned_bins)
+    plt.tight_layout()
+    plt.savefig(output_path.replace(".png", "_ned.png"), dpi=300)
+    plt.close()
+
+    print(f"✅ 柱状图已保存：{output_path.replace('.png', '_length.png')} 和 {output_path.replace('.png', '_ned.png')}")
+
+if __name__ == "__main__":
+
+    meta_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10_last-mode/output_processed_ocr_Gundam.jsonl"
+    data = read_jsonl(meta_path)
+
+    # 1. 计算NED
+    for item in data:
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                orig = extent["edited"]
+                pred = extent["ocr"]
+                extent["NED_ocr"] = compute_edit_distance(orig, pred)
+
+    save_jsonl(data, "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10_last-mode/output_processed_ocr_Gundam_result.jsonl")
+
+    # 1. 不同维度的模型性能      最大程度。
+    metric_dim = {
+        "形近字替换": 0,
+        "音近/同音字替换": 0,
+        "语序颠倒": 0,
+        "字符增衍": 0,
+        "字符缺失": 0
+    }
+    for item in data:
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                # TODO 不同level相对于原始字符串的NED也不同，要进行区分。即，数据集本身有bias，导致其他的自变量没有得到控制。
+                if extent["level"] == 1.0:
+                    metric_dim[dim] += extent["NED_ocr"]
+    for k, v in metric_dim.items():
+        metric_dim[k] = v / len(data)
+    print(metric_dim)
+    
+    # 2. 不同文字密度的模型性能。   最大程度。 分维度，出5条曲线。或者取均值？
+    metric_p = {
+        "形近字替换": [],
+        "音近/同音字替换": [],
+        "语序颠倒": [],
+        "字符增衍": [],
+        "字符缺失": []
+    }
+    for item in data:
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                if extent["level"] == 1.0:
+                    metric_p[dim].append([item["length"], extent["NED_ocr"]])
+    plot_density_ned(metric_p["形近字替换"], save_path="/vol/fit_p_ned.png")
+
+
+    metric_3d = []
+    # 3. 不同程度。                先不考虑文字密度。 文字密度不同，也是个自变量在这里。          分维度，出5条曲线。或者取均值？
+    # TODO
+    for item in data:
+        for dim, v in item["rewrite"].items():
+            for extent in v["extents"]:
+                metric_3d.append([item["length"], extent["NED"], extent["NED_ocr"]])
+    fit_and_plot_3d(metric_3d, "/vol/fit_3d.png")
+
+    # 统计自变量分布
+    plot_length_ned_bar(data, output_path="/vol/length_ned_bar.png",
+                    length_bin_width=500, ned_bin_width=0.05)

scripts/3_calu_order.py

@@ -0,0 +1,18 @@
+import json
+
+json_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/sample200_len1.0-1.2k/merged_ocr.json"
+with open(json_path, 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+num = cnt1 = cnt2 = 0
+for item in data:
+    num += 1
+    if item["spans"][0]["before"] in item["content_ocr"] and item["spans"][0]["after"] not in item["tiny_shuffled_content_ocr"]:
+        cnt1 += 1
+    elif item["spans"][0]["before"] not in item["content_ocr"] and item["spans"][0]["after"] in item["tiny_shuffled_content_ocr"]:
+        cnt2 += 1
+print(f"normal正确但是替换后错误：{cnt1}， normal错误但是替换后正确：{cnt2}")
+
+# # 如果想保存每条样本的准确率：
+# with open(json_path.replace(".json", "_acc.json"), "w", encoding="utf-8") as f:
+#     json.dump(sample_accuracies, f, ensure_ascii=False, indent=2)

scripts/Levenshtein1.py

@@ -0,0 +1,9 @@
+# 使用Levenshtein库计算编辑距离
+
+import Levenshtein
+
+pred = "你好"
+gt = "你好11"
+upper_len = max(len(pred), len(gt))
+edit_dist = Levenshtein.distance(pred, gt) / upper_len
+print(edit_dist)

scripts/fit_2d.py

@@ -0,0 +1,75 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.metrics import r2_score
+
+def plot_density_ned(data, degree=2, save_path="density_ned_fit.png"):
+    """
+    根据输入二维数组 (density, NED)，拟合并可视化趋势。
+
+    参数:
+        data: 二维数组或列表 [[density1, ned1], [density2, ned2], ...]
+        degree: 拟合多项式阶数 (默认2阶)，二阶多项式拟合
+        save_path: 保存路径 (默认为 'density_ned_fit.png')
+
+    输出:
+        保存拟合图像，并返回拟合系数与R²值。
+    """
+    # 转为numpy数组
+    data = np.array(data)
+    X = data[:, 0].reshape(-1, 1)  # 文字密度
+    y = data[:, 1]                 # NED指标
+
+    # 多项式特征转换
+    poly = PolynomialFeatures(degree=degree)
+    X_poly = poly.fit_transform(X)
+
+    # 拟合回归模型
+    model = LinearRegression()
+    model.fit(X_poly, y)
+
+    # 预测与R²
+    y_pred = model.predict(X_poly)
+    r2 = r2_score(y, y_pred)
+
+    # 平滑曲线点
+    X_plot = np.linspace(X.min(), X.max(), 200).reshape(-1, 1)
+    X_plot_poly = poly.transform(X_plot)
+    y_plot = model.predict(X_plot_poly)
+
+    # 绘图
+    plt.figure(figsize=(8, 6))
+    plt.scatter(X, y, color='royalblue', alpha=0.7, label='Data points')
+    plt.plot(X_plot, y_plot, color='crimson', linewidth=2.5, label=f'Polynomial Fit (deg={degree})')
+
+    plt.xlabel("Text Density", fontsize=14)
+    plt.ylabel("NED", fontsize=14)
+    plt.title("Relationship between Text Density and NED", fontsize=16, pad=15)
+    plt.grid(alpha=0.3)
+    plt.legend(fontsize=12)
+    plt.tight_layout()
+
+    # 保存高分辨率图片
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+    print(f"✅ 拟合完成，图片已保存至：{save_path}")
+    print(f"📈 拟合公式系数: {model.coef_}")
+    print(f"📊 R² = {r2:.4f}")
+
+    return model.coef_, r2
+
+
+# 示例使用
+if __name__ == "__main__":
+    data = [
+        [0.1, 0.12],
+        [0.2, 0.18],
+        [0.3, 0.25],
+        [0.4, 0.32],
+        [0.5, 0.45],
+        [0.6, 0.51],
+        [0.7, 0.62],
+    ]
+    plot_density_ned(data, degree=2, save_path="/vol/density_ned_fit.png")

scripts/fit_3d.py

@@ -0,0 +1,69 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import r2_score
+from mpl_toolkits.mplot3d import Axes3D
+
+def fit_and_plot_3d(data, output_path="fit_surface.png"):
+    """
+    对两个自变量（文字密度、程序）和一个因变量（NED）进行线性拟合并可视化
+
+    参数:
+        data: 二维数组或列表，每行格式为 [文字密度, 程序, NED]
+        output_path: 图片保存路径
+    """
+    data = np.array(data)
+    X = data[:, :2]  # 自变量（文字密度、程序）
+    y = data[:, 2]   # 因变量（NED）
+
+    # 拟合多元线性回归
+    model = LinearRegression()
+    model.fit(X, y)
+    y_pred = model.predict(X)
+
+    # 计算R²
+    r2 = r2_score(y, y_pred)
+    print(f"✅ 拟合完成，R² = {r2:.4f}")
+    print(f"回归系数: {model.coef_}, 截距: {model.intercept_:.4f}")
+
+    # 创建网格点用于绘制拟合面
+    x1_range = np.linspace(X[:,0].min(), X[:,0].max(), 50)
+    x2_range = np.linspace(X[:,1].min(), X[:,1].max(), 50)
+    X1, X2 = np.meshgrid(x1_range, x2_range)
+    X_grid = np.c_[X1.ravel(), X2.ravel()]
+    Y_pred = model.predict(X_grid).reshape(X1.shape)
+
+    # 绘制3D散点+拟合平面
+    fig = plt.figure(figsize=(8, 6))
+    ax = fig.add_subplot(111, projection='3d')
+
+    ax.scatter(X[:,0], X[:,1], y, color='blue', label='Data points')
+    ax.plot_surface(X1, X2, Y_pred, color='lightcoral', alpha=0.6, label='Fitted surface')
+
+    ax.set_xlabel('Text Density')
+    ax.set_ylabel('Program')
+    ax.set_zlabel('NED')
+    ax.set_title(f'3D Regression Fit (R²={r2:.3f})')
+
+    # 保存图片
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=300)
+    plt.close(fig)
+    print(f"📊 图像已保存到: {output_path}")
+
+# 示例
+if __name__ == "__main__":
+    # 示例数据 [文字密度, 程序, NED]
+    sample_data = [
+        [0.1, 1, 0.05],
+        [0.2, 1, 0.10],
+        [0.3, 2, 0.18],
+        [0.4, 2, 0.23],
+        [0.5, 3, 0.28],
+        [0.6, 3, 0.35],
+        [0.7, 4, 0.38],
+        [0.8, 4, 0.45],
+        [0.9, 5, 0.50],
+    ]
+
+    fit_and_plot_3d(sample_data, "ned_fit.png")

scripts/gen_random_char.py

@@ -0,0 +1,52 @@
+import random
+import json
+import os
+
+
+
+def load_vocab_zh():
+    COMMON_CHARS = ""
+    with open("/vol/zhaoy/ds-ocr/scripts/zh_level1_3500.txt", "r", encoding="utf-8") as f:
+        for line in f:
+            parts = line.strip().split('\t')
+            if len(parts) >= 2:  # 保证至少有编号和汉字
+                char = parts[1]
+                # 只保留真正的汉字（防止空行或错误字符）
+                if '\u4e00' <= char <= '\u9fff':
+                    COMMON_CHARS += char
+    # print(f"✅ 共读取 {len(COMMON_CHARS)} 个汉字。")
+    # print(COMMON_CHARS[:50])
+    return COMMON_CHARS
+
+def random_common_chinese(COMMON_CHARS, length):
+    return ''.join(random.choice(COMMON_CHARS) for _ in range(length))
+
+def generate_dataset(num_samples, save_path):
+    """生成多个样本并保存为 JSON"""
+    data = []
+    os.makedirs("images", exist_ok=True)
+
+    for i in range(1, num_samples + 1):
+        sample_id = f"RS{i:03d}"
+        length = 2000  # 长度
+
+        COMMON_CHARS = load_vocab_zh()
+        content = random_common_chinese(COMMON_CHARS, length)
+        image_path = f"images/{sample_id}.png"  # 可后续生成图片时用
+
+        data.append({
+            "id": sample_id,
+            "image_path": image_path,
+            "content": content
+        })
+
+    # 保存为 JSON 文件
+    with open(save_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+    print(f"✅ 已生成 {num_samples} 条样本，保存至：{save_path}")
+
+
+if __name__ == "__main__":
+    save_path = "/vol/zhaoy/ds-ocr/data/rand_zh_2k/meta.json"
+    generate_dataset(10, save_path)  # 样本数量

scripts/resize_image.py

@@ -0,0 +1,15 @@
+from PIL import Image
+
+# 读取图片
+img_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/CCI3_100-5k_sample100_interval500_per10/images/char_deletion/RS061_ned-0.0907.png"   # 原始图片路径
+output_path = "/vol/RS061_ned-0.0907.png"   # 保存路径
+target_size = (1280, 1280)  # 指定尺寸 (宽, 高)
+
+# 打开并 resize
+img = Image.open(img_path)
+img_resized = img.resize(target_size, Image.Resampling.LANCZOS)  # 高质量缩放
+
+# 保存
+img_resized.save(output_path)
+
+print(f"✅ 图片已保存到 {output_path}，尺寸为 {img_resized.size}")

scripts/tiny_shuffle.py

@@ -0,0 +1,132 @@
+import random
+import re
+
+def random_swap_contiguous_v1(text: str, n_swaps: int = 1, max_retry: int = 10):
+    """
+    在字符串中随机选取连续的非标点、非数字中文字符片段，
+    并在该片段内随机交换字符，同时记录修改区域的索引。
+    若打乱后与原字符串相同，则重试，最多 max_retry 次。
+    """
+    chinese_spans = [(m.start(), m.end()) for m in re.finditer(r'[\u4e00-\u9fa5]+', text)]
+    if not chinese_spans:
+        return text, []
+
+    text_list = list(text)
+    modified_spans = []
+
+    for _ in range(n_swaps):
+        for attempt in range(max_retry):
+            start, end = random.choice(chinese_spans)
+            length = end - start
+            if length < 2:
+                continue
+
+            sub_len = random.randint(2, min(5, length))  # [2,5]
+            sub_start = random.randint(start, end - sub_len)
+            sub_end = sub_start + sub_len
+
+            before = ''.join(text_list[sub_start:sub_end])
+            sub_chars = text_list[sub_start:sub_end]
+
+            # 尝试打乱，直到不同
+            shuffled = sub_chars[:]
+            random.shuffle(shuffled)
+            after = ''.join(shuffled)
+
+            if after != before:
+                text_list[sub_start:sub_end] = shuffled
+                modified_spans.append({
+                    "start": sub_start,
+                    "end": sub_end,
+                    "before": before,
+                    "after": after
+                })
+                break  # 成功打乱后跳出 retry 循环
+        else:
+            print("⚠️ 无法有效打乱片段（内容重复），已跳过。")
+
+    return ''.join(text_list), modified_spans
+
+def random_swap_contiguous(text: str, n_swaps: int = 1, max_retry: int = 10):
+    """
+    在字符串中随机扰动连续片段：
+    - 中文：在连续中文片段内打乱若干个连续汉字
+    - 英文：在连续英文单词序列内打乱若干个连续单词
+    打乱后记录修改区域索引和变化内容。
+    """
+
+    # 拆分文本为token，保留分隔符位置
+    tokens = re.findall(r'[\u4e00-\u9fa5]+|[A-Za-z]+(?:\s+[A-Za-z]+)*|[^\u4e00-\u9fa5A-Za-z]+', text)
+
+    text_list = list(text)
+    modified_spans = []
+
+    # 找出中文和英文片段（带索引范围）
+    spans = []
+    for m in re.finditer(r'[\u4e00-\u9fa5]+|([A-Za-z]+(?:\s+[A-Za-z]+)*)', text):
+        start, end = m.span()
+        spans.append((start, end, 'en' if m.group(1) else 'zh'))
+
+    if not spans:
+        return text, []
+
+    for _ in range(n_swaps):
+        for attempt in range(max_retry):
+            start, end, lang = random.choice(spans)
+            segment = text[start:end]
+
+            if lang == 'zh':
+                # 中文：随机扰动连续2~5个字符
+                if len(segment) < 2:
+                    continue
+                sub_len = random.randint(2, min(5, len(segment)))
+                sub_start = random.randint(0, len(segment) - sub_len)
+                sub_end = sub_start + sub_len
+                before = segment[sub_start:sub_end]
+                sub_chars = list(before)
+                random.shuffle(sub_chars)
+                after = ''.join(sub_chars)
+                if after == before:
+                    continue
+                new_segment = segment[:sub_start] + after + segment[sub_end:]
+            else:
+                # 英文：按单词打乱
+                words = segment.split()
+                if len(words) < 2:
+                    continue
+                sub_len = random.randint(2, min(4, len(words)))
+                sub_start = random.randint(0, len(words) - sub_len)
+                sub_end = sub_start + sub_len
+                before = ' '.join(words[sub_start:sub_end])
+                sub_words = words[sub_start:sub_end]
+                random.shuffle(sub_words)
+                after = ' '.join(sub_words)
+                if after == before:
+                    continue
+                new_segment = ' '.join(words[:sub_start] + sub_words + words[sub_end:])
+
+            # 替换文本
+            text = text[:start] + new_segment + text[end:]
+            modified_spans.append({
+                "start": start,
+                "end": end,
+                "lang": lang,
+                "before": segment,
+                "after": new_segment
+            })
+            break
+        else:
+            print("⚠️ 无法有效打乱片段（内容重复），已跳过。")
+
+    return text, modified_spans
+
+if __name__ == "__main__":
+    # 示例
+    s = "需要在俄罗斯莫斯科和中国北京各转一次机，然后才能抵达西安，期间至少需要25个小时。"
+    new_s, spans = random_swap_contiguous(s, n_swaps=1)
+
+    print("原句：  ", s)
+    print("打乱后：", new_s)
+    print("修改记录：")
+    for span in spans:
+        print(span)

scripts/vis/vis.py

@@ -0,0 +1,129 @@
+import json
+import difflib
+
+def highlight_diff(a, b):
+    """生成红色高亮 HTML，红底=不同部分"""
+    matcher = difflib.SequenceMatcher(None, a, b)
+    html_a, html_b = [], []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            html_a.append(a[i1:i2])
+            html_b.append(b[j1:j2])
+        elif tag == 'replace' or tag == 'delete':
+            html_a.append(f'<span class="del">{a[i1:i2]}</span>')
+        elif tag == 'insert':
+            html_b.append(f'<span class="ins">{b[j1:j2]}</span>')
+    return ''.join(html_a), ''.join(html_b)
+
+
+def generate_html(data, output_path="ocr_diff_viewer.html"):
+    """生成带翻页功能的HTML"""
+    html_items = []
+
+    for i, item in enumerate(data):
+        # 修改这里
+        text = item.get("tiny_shuffled_content", "")
+        ocr = item.get("tiny_shuffled_content_ocr", "").replace("\n", "").replace(" ", "")
+        html_text, html_ocr = highlight_diff(text, ocr)
+
+        html_items.append(f"""
+        <div class="page" id="page-{i}" style="display: {'block' if i==0 else 'none'};">
+            <h2>样本 {i+1}/{len(data)}</h2>
+            <div class="block">
+                <h3>原文（text）</h3>
+                <div class="box">{html_text}</div>
+            </div>
+            <div class="block">
+                <h3>OCR 结果（ocr）</h3>
+                <div class="box">{html_ocr}</div>
+            </div>
+        </div>
+        """)
+
+    html_content = f"""
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <title>OCR Diff Viewer</title>
+        <style>
+            body {{
+                font-family: "Courier New", monospace;
+                background-color: #f6f6f6;
+                padding: 20px;
+            }}
+            .block {{
+                margin-bottom: 30px;
+            }}
+            .box {{
+                background: #fff;
+                border: 1px solid #ccc;
+                padding: 15px;
+                white-space: pre-wrap;
+                font-size: 16px;
+                line-height: 1.5;
+            }}
+            .del {{ background-color: #ffcccc; }}
+            .ins {{ background-color: #ccffcc; }}
+            .nav {{
+                text-align: center;
+                margin-top: 30px;
+            }}
+            button {{
+                font-size: 16px;
+                padding: 6px 12px;
+                margin: 0 8px;
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>📘 OCR 文本差异可视化</h1>
+        {"".join(html_items)}
+        <div class="nav">
+            <button onclick="prevPage()">上一条</button>
+            <button onclick="nextPage()">下一条</button>
+            <p id="page-indicator"></p>
+        </div>
+
+        <script>
+            let currentPage = 0;
+            const total = {len(data)};
+            const indicator = document.getElementById("page-indicator");
+
+            function showPage(i) {{
+                document.querySelectorAll('.page').forEach((el, idx) => {{
+                    el.style.display = idx === i ? 'block' : 'none';
+                }});
+                indicator.innerText = `第 ${{i+1}} / ${{total}} 条`;
+            }}
+
+            function nextPage() {{
+                if (currentPage < total - 1) {{
+                    currentPage++;
+                    showPage(currentPage);
+                }}
+            }}
+            function prevPage() {{
+                if (currentPage > 0) {{
+                    currentPage--;
+                    showPage(currentPage);
+                }}
+            }}
+
+            showPage(currentPage);
+        </script>
+    </body>
+    </html>
+    """
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html_content)
+    print(f"✅ 可视化结果已保存到 {output_path}")
+
+
+if __name__ == "__main__":
+    # 示例：加载 JSON 文件
+    input_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/sample10_len1.0-1.2k/merged_ocr.json"  # 你自己的路径
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    generate_html(data, "ocr_diff_viewer.html")

scripts/vis/vis_v2.py

@@ -0,0 +1,151 @@
+import json
+import difflib
+
+def highlight_diff(a, b):
+    """生成红色高亮 HTML，红底=不同部分"""
+    matcher = difflib.SequenceMatcher(None, a, b)
+    html_a, html_b = [], []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            html_a.append(a[i1:i2])
+            html_b.append(b[j1:j2])
+        elif tag in ('replace', 'delete'):
+            html_a.append(f'<span class="del">{a[i1:i2]}</span>')
+        elif tag == 'insert':
+            html_b.append(f'<span class="ins">{b[j1:j2]}</span>')
+    return ''.join(html_a), ''.join(html_b)
+
+
+def generate_html(data, output_path="ocr_diff_viewer.html"):
+    """生成带翻页功能的HTML"""
+    html_items = []
+
+    for i, item in enumerate(data):
+        text = item.get("tiny_shuffled_content", "")
+        ocr = item.get("tiny_shuffled_content_ocr", "").replace("\n", "").replace(" ", "")
+        start = item["spans"][0]["start"]
+        end = item["spans"][0]["end"]
+
+        # 1️⃣ 添加黄色高亮标注
+        if start is not None and end is not None and 0 <= start < len(text) and start < end <= len(text):
+            text_highlighted = (
+                text[:start]
+                + f'<span class="highlight">{text[start:end]}</span>'
+                + text[end:]
+            )
+        else:
+            text_highlighted = text
+
+        # 2️⃣ difflib 比较
+        html_text, html_ocr = highlight_diff(text_highlighted, ocr)
+
+        # 3️⃣ 新增 "before" 一栏
+        html_items.append(f"""
+        <div class="page" id="page-{i}" style="display: {'block' if i==0 else 'none'};">
+            <h2>样本 {i+1}/{len(data)}</h2>
+
+            <div class="block">
+                <h3>Before（空）</h3>
+                <div class="box"></div>
+            </div>
+
+            <div class="block">
+                <h3>原文（text）</h3>
+                <div class="box">{html_text}</div>
+            </div>
+
+            <div class="block">
+                <h3>OCR 结果（ocr）</h3>
+                <div class="box">{html_ocr}</div>
+            </div>
+        </div>
+        """)
+
+    # --- HTML 模板 ---
+    html_content = f"""
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <title>OCR Diff Viewer</title>
+        <style>
+            body {{
+                font-family: "Courier New", monospace;
+                background-color: #f6f6f6;
+                padding: 20px;
+            }}
+            .block {{
+                margin-bottom: 30px;
+            }}
+            .box {{
+                background: #fff;
+                border: 1px solid #ccc;
+                padding: 15px;
+                white-space: pre-wrap;
+                font-size: 16px;
+                line-height: 1.5;
+            }}
+            .del {{ background-color: #ffcccc; }}
+            .ins {{ background-color: #ccffcc; }}
+            .highlight {{ background-color: #fff59d; }}  /* 黄色标注 */
+            .nav {{
+                text-align: center;
+                margin-top: 30px;
+            }}
+            button {{
+                font-size: 16px;
+                padding: 6px 12px;
+                margin: 0 8px;
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>📘 OCR 文本差异可视化</h1>
+        {"".join(html_items)}
+        <div class="nav">
+            <button onclick="prevPage()">上一条</button>
+            <button onclick="nextPage()">下一条</button>
+            <p id="page-indicator"></p>
+        </div>
+
+        <script>
+            let currentPage = 0;
+            const total = {len(data)};
+            const indicator = document.getElementById("page-indicator");
+
+            function showPage(i) {{
+                document.querySelectorAll('.page').forEach((el, idx) => {{
+                    el.style.display = idx === i ? 'block' : 'none';
+                }});
+                indicator.innerText = `第 ${{i+1}} / ${{total}} 条`;
+            }}
+
+            function nextPage() {{
+                if (currentPage < total - 1) {{
+                    currentPage++;
+                    showPage(currentPage);
+                }}
+            }}
+            function prevPage() {{
+                if (currentPage > 0) {{
+                    currentPage--;
+                    showPage(currentPage);
+                }}
+            }}
+
+            showPage(currentPage);
+        </script>
+    </body>
+    </html>
+    """
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html_content)
+    print(f"✅ 可视化结果已保存到 {output_path}")
+
+
+if __name__ == "__main__":
+    input_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/sample10_len1.0-1.2k/merged_ocr.json"
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    generate_html(data, "ocr_diff_viewer.html")

scripts/vis/vis_v3.py

@@ -0,0 +1,171 @@
+import json
+import difflib
+
+def highlight_diff(a, b):
+    """生成红色/绿色高亮 HTML"""
+    matcher = difflib.SequenceMatcher(None, a, b)
+    html_a, html_b = [], []
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == 'equal':
+            html_a.append(a[i1:i2])
+            html_b.append(b[j1:j2])
+        elif tag in ('replace', 'delete'):
+            html_a.append(f'<span class="del">{a[i1:i2]}</span>')
+        elif tag == 'insert':
+            html_b.append(f'<span class="ins">{b[j1:j2]}</span>')
+    return ''.join(html_a), ''.join(html_b)
+
+
+def insert_highlight(html_text, start, end):
+    """在 HTML 文本中插入黄色下划线（基于字符索引）"""
+    # 去掉 HTML 标签的干扰：我们对纯文本位置标注
+    # difflib 输出可能含 <span>，所以要对“裸文本索引”映射
+    plain = ''
+    mapping = []  # plain[i] -> html_text[idx]
+    inside_tag = False
+    for idx, ch in enumerate(html_text):
+        if ch == '<':
+            inside_tag = True
+        elif ch == '>':
+            inside_tag = False
+        elif not inside_tag:
+            mapping.append(idx)
+            plain += ch
+
+    if end > len(mapping):
+        return html_text  # 索引越界保护
+
+    # 将 start/end 转为 html_text 索引
+    html_start = mapping[start]
+    html_end = mapping[end - 1] + 1
+
+    return (
+        html_text[:html_start]
+        + f'<span class="highlight" title="标注区域: {start}-{end}">'
+        + html_text[html_start:html_end]
+        + '</span>'
+        + html_text[html_end:]
+    )
+
+
+def generate_html(data, output_path="ocr_diff_viewer.html"):
+    html_items = []
+
+    for i, item in enumerate(data):
+        text = item.get("tiny_shuffled_content", "")
+        ocr = item.get("tiny_shuffled_content_ocr", "").replace("\n", "").replace(" ", "") # 英文不替换空格
+        span = item.get("spans", [{}])[0]
+        start, end = span.get("start"), span.get("end")
+
+        # text = item.get("content", "")
+        # ocr = item.get("content_ocr", "").replace("\n", "").replace(" ", "") # 英文不替换空格
+        # start = end = None
+
+        # text = item.get("shuffled_content", "")
+        # ocr = item.get("shuffled_content_ocr", "").replace("\n", "").replace(" ", "") # 英文不替换空格
+        # start = end = None
+
+        html_text, html_ocr = highlight_diff(text, ocr)
+
+        # ✅ difflib 完成后再插入黄色下划线
+        if start is not None and end is not None:
+            html_text = insert_highlight(html_text, start, end)
+
+        html_items.append(f"""
+        <div class="page" id="page-{i}" style="display: {'block' if i==0 else 'none'};">
+            <h2>样本 {i+1}/{len(data)}</h2>
+
+            <div class="block">
+                <h3>原文（text）</h3>
+                <div class="box">{html_text}</div>
+            </div>
+
+            <div class="block">
+                <h3>OCR 结果（ocr）</h3>
+                <div class="box">{html_ocr}</div>
+            </div>
+        </div>
+        """)
+
+    html_template = f"""
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <title>OCR Diff Viewer</title>
+        <style>
+            body {{
+                font-family: "Courier New", monospace;
+                background-color: #f6f6f6;
+                padding: 20px;
+            }}
+            .box {{
+                background: #fff;
+                border: 1px solid #ccc;
+                padding: 15px;
+                white-space: pre-wrap;
+                font-size: 16px;
+                line-height: 1.5;
+            }}
+            .del {{ background-color: #ffcccc; }}
+            .ins {{ background-color: #ccffcc; }}
+            .highlight {{
+                text-decoration: underline solid #FFD700 3px;
+                text-underline-offset: 4px;
+                cursor: help;
+                background-color: rgba(255, 215, 0, 0.15);
+            }}
+            .highlight:hover {{
+                background-color: rgba(255, 215, 0, 0.35);
+            }}
+        </style>
+    </head>
+    <body>
+        <h1>📘 OCR 文本差异可视化</h1>
+        {"".join(html_items)}
+        <div class="nav" style="text-align:center; margin-top:30px;">
+            <button onclick="prevPage()">上一条</button>
+            <button onclick="nextPage()">下一条</button>
+            <p id="page-indicator"></p>
+        </div>
+        <script>
+            let currentPage = 0;
+            const total = {len(data)};
+            const indicator = document.getElementById("page-indicator");
+
+            function showPage(i) {{
+                document.querySelectorAll('.page').forEach((el, idx) => {{
+                    el.style.display = idx === i ? 'block' : 'none';
+                }});
+                indicator.innerText = `第 ${{i+1}} / ${{total}} 条`;
+            }}
+
+            function nextPage() {{
+                if (currentPage < total - 1) {{
+                    currentPage++;
+                    showPage(currentPage);
+                }}
+            }}
+            function prevPage() {{
+                if (currentPage > 0) {{
+                    currentPage--;
+                    showPage(currentPage);
+                }}
+            }}
+
+            showPage(currentPage);
+        </script>
+    </body>
+    </html>
+    """
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html_template)
+    print(f"✅ 已生成: {output_path}")
+
+
+if __name__ == "__main__":
+    input_path = "/vol/zhaoy/ds-ocr/data/CCI3-Data/sample200_len1.0-1.2k/merged_ocr.json"
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    generate_html(data)