feat: add integrity check to copy script, and add .gitignore

.gitignore

@@ -1,2 +1,4 @@
 __pycache__/
-*.egg-info/
+*.egg-info/
+raw_images/
+*_test/

scripts/copy_image.py

@@ -2,15 +2,10 @@ import os
 import json
 import shutil
 from pathlib import Path
+from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
-
-# 如果没有安装 tqdm，可以注释掉下面这行，并将后面的 tqdm() 包裹去掉
-try:
-    from tqdm import tqdm
-except ImportError:
-    # 如果没装 tqdm，提供一个简单的替代，防止报错
-    def tqdm(iterable, **kwargs):
-        return iterable
+from PIL import Image, UnidentifiedImageError
+from tqdm import tqdm
 
 # ===================== 配置区域 (请在此处修改) =====================
 
@@ -23,23 +18,48 @@ TARGET_PREFIX = 'data/raw_images'
 # 3. 图片实际存在的源目录 (源前缀)
 SOURCE_ROOT = '/run/determined/NAS1/public/lixinyuan/interleaved-co3d/data/original'
 
-# 4. [新增] 多线程并发数量
-# 建议设置在 8 到 32 之间。如果是在机械硬盘上，数值不宜过大；SSD 或网络存储可以适当调大。
-MAX_WORKERS = 12
+# 4. 多线程并发数量
+MAX_WORKERS = 16
+
+# 5. 错误日志保存路径
+ERROR_LOG_FILE = 'copy_errors.log'
 
 # =================================================================
 
 
-def collect_image_paths(question_root):
+def is_image_valid(file_path):
+    """
+    检查图片是否有效
+    1. 检查文件大小是否 > 0
+    2. 使用 PIL 检查文件头和结构是否完整
+    """
+    # 1. 基础检查：文件是否存在且大小不为0
+    if not os.path.exists(file_path) or os.path.getsize(file_path) == 0:
+        return False
+
+    # 2. 深度检查：使用 PIL 验证 (如果安装了的话)
+    if PIL_AVAILABLE:
+        try:
+            with Image.open(file_path) as img:
+                img.verify()  # 验证文件完整性，不会加载整个图像，速度较快
+            return True
+        except (IOError, SyntaxError, UnidentifiedImageError):
+            return False
+    
+    return True
+
+
+def collect_image_paths_and_refs(question_root):
     """
-    遍历 question_root 下的所有 jsonl 文件，提取所有唯一的图片路径
+    遍历 question_root 下的所有 jsonl 文件，建立索引
     """
     unique_paths = set()
+    image_ref_map = defaultdict(list)
     jsonl_files = []
 
     if not os.path.exists(question_root):
         print(f"[Error] 找不到目录: {question_root}")
-        return set()
+        return set(), {}
 
     print(f"[*] 正在扫描 {question_root} 下的 jsonl 文件...")
     for root, dirs, files in os.walk(question_root):
@@ -47,30 +67,37 @@ def collect_image_paths(question_root):
             if file.endswith('.jsonl'):
                 jsonl_files.append(os.path.join(root, file))
 
-    print(f"[*] 找到 {len(jsonl_files)} 个 jsonl 文件，开始解析图片路径...")
+    print(f"[*] 找到 {len(jsonl_files)} 个 jsonl 文件，开始解析...")
     
     for file_path in tqdm(jsonl_files, desc="解析 JSONL"):
+        file_name = os.path.basename(file_path)
         with open(file_path, 'r', encoding='utf-8') as f:
-            for line in f:
+            for line_num, line in enumerate(f):
                 line = line.strip()
                 if not line:
                     continue
                 try:
                     data = json.loads(line)
+                    q_id = data.get('id', f"line_{line_num}")
+                    ref_info = f"{file_name} -> ID:{q_id}"
+
                     if 'images' in data and isinstance(data['images'], dict):
                         for img_path in data['images'].values():
                             unique_paths.add(img_path)
+                            image_ref_map[img_path].append(ref_info)
+                            
                 except json.JSONDecodeError:
                     continue
 
-    print(f"[*] 总共找到 {len(unique_paths)} 张唯一的图片需要复制。")
-    return unique_paths
+    print(f"[*] 总共找到 {len(unique_paths)} 张唯一的图片需要处理。")
+    return unique_paths, image_ref_map
 
 
 def process_single_image(target_path_str, src_root_path, tgt_prefix_path):
     """
-    单个图片处理逻辑，供多线程调用
-    返回状态码: 'success', 'skip', 'fail', 'error_msg'
+    单个图片处理逻辑
+    返回: (status, message)
+    status: 'success' (新复制), 'skip' (已存在且完好), 'fixed' (已存在但损坏，已覆盖), 'fail' (出错)
     """
     try:
         target_full_path = Path(target_path_str)
@@ -79,84 +106,154 @@ def process_single_image(target_path_str, src_root_path, tgt_prefix_path):
         try:
             relative_path = target_full_path.relative_to(tgt_prefix_path)
         except ValueError:
-            return 'fail', f"路径格式不匹配: {target_path_str}"
+            return 'fail', f"路径格式不匹配 (不包含 {tgt_prefix_path})"
 
         # 2. 构造真实的源文件路径
         source_full_path = src_root_path / relative_path
 
-        # 3. 检查源文件是否存在
+        # 3. 检查源文件是否存在 (如果源文件都不在，那就没法复制/修复了)
         if not source_full_path.exists():
-            return 'fail', None # 源文件缺失，不打印具体路径以免刷屏，或者在外部统计
+            return 'fail', f"源文件缺失: {source_full_path}"
 
-        # 4. 检查目标文件是否已存在
+        # 4. 检查目标文件逻辑 (核心修改部分)
         if target_full_path.exists():
-            return 'skip', None
+            # 检查目标文件是否完好
+            if is_image_valid(target_full_path):
+                return 'skip', None
+            else:
+                # 文件存在但损坏，准备覆盖
+                # print(f"发现损坏文件，准备修复: {target_full_path}") # 调试用，多线程下不建议打印
+                pass # 继续向下执行复制逻辑，shutil.copy2 会自动覆盖
 
-        # 5. 创建目标文件夹 (exist_ok=True 是线程安全的)
+        # 5. 创建目标文件夹
         target_full_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # 6. 复制文件
+        # 6. 复制文件 (如果目标存在，copy2 会直接覆盖)
         shutil.copy2(source_full_path, target_full_path)
+        
+        # 如果之前文件存在（代码走到这里说明之前不存在 或者 之前存在但损坏了）
+        # 为了统计准确，我们可以再次判断一下之前是否存在，但为了性能，
+        # 这里简单地将所有执行了 copy 的操作视为 success 或 fixed。
+        # 我们可以通过判断 "是否是覆盖操作" 来区分，但 copy2 不返回这个信息。
+        # 简单起见：只要执行了 copy，如果之前文件存在且损坏，那就是 fixed。
+        # 但由于并发，这里很难精确判断 "之前是否存在"，
+        # 所以我们统一逻辑：只要执行了 copy，就是 'success' (包含修复)。
+        # 如果你想精确区分 'fixed'，需要在 copy 前记录一下状态。
+        
+        # 稍微精确一点的返回逻辑：
+        # 如果刚才 is_image_valid 返回 False 且 exists 为 True，那就是 fixed。
+        # 但为了代码简洁，我们在上面没有保留这个状态。
+        # 让我们稍微调整一下逻辑结构以便区分。
         return 'success', None
 
     except Exception as e:
-        return 'fail', f"复制异常: {e}"
+        return 'fail', f"系统异常: {e}"
+
+# 为了支持 'fixed' 统计，重写一下 process_single_image 的内部逻辑结构
+def process_single_image_refined(target_path_str, src_root_path, tgt_prefix_path):
+    try:
+        target_full_path = Path(target_path_str)
+
+        try:
+            relative_path = target_full_path.relative_to(tgt_prefix_path)
+        except ValueError:
+            return 'fail', f"路径格式不匹配 (不包含 {tgt_prefix_path})"
+
+        source_full_path = src_root_path / relative_path
+
+        if not source_full_path.exists():
+            return 'fail', f"源文件缺失: {source_full_path}"
+
+        # === 检查目标文件 ===
+        is_repair = False
+        if target_full_path.exists():
+            if is_image_valid(target_full_path):
+                return 'skip', None
+            else:
+                # 存在但损坏，标记为修复模式
+                is_repair = True
+        
+        # === 执行复制 ===
+        target_full_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source_full_path, target_full_path)
+        
+        return 'fixed' if is_repair else 'success', None
+
+    except Exception as e:
+        return 'fail', f"系统异常: {e}"
 
 
-def copy_images_multithread(unique_paths, source_root, target_prefix, max_workers):
+def copy_images_multithread(unique_paths, image_ref_map, source_root, target_prefix, max_workers, log_file_path):
     """
     多线程执行复制操作
     """
-    success_count = 0
-    skip_count = 0
-    fail_count = 0
+    success_count = 0 # 新复制
+    skip_count = 0    # 已存在且完好
+    fixed_count = 0   # 已存在但损坏，已修复
+    fail_count = 0    # 失败
 
     src_root_path = Path(source_root)
     tgt_prefix_path = Path(target_prefix)
 
-    print(f"[*] 开始多线程复制图片 (线程数: {max_workers})...")
-    print(f"    源目录: {src_root_path}")
-    print(f"    目标前缀: {tgt_prefix_path}")
-
-    # 使用 ThreadPoolExecutor 管理线程池
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        # 提交所有任务
-        # future_to_path 是一个字典，用于在出错时知道是哪个路径出的错（可选）
-        futures = {
-            executor.submit(process_single_image, path, src_root_path, tgt_prefix_path): path 
-            for path in unique_paths
-        }
-
-        # 使用 tqdm 包装 as_completed 来显示进度条
-        for future in tqdm(as_completed(futures), total=len(unique_paths), desc="复制进度"):
-            status, msg = future.result()
-            
-            if status == 'success':
-                success_count += 1
-            elif status == 'skip':
-                skip_count += 1
-            elif status == 'fail':
-                fail_count += 1
-                if msg:
-                    # 只有非源文件缺失的错误才打印，避免源文件缺失太多刷屏
-                    # 如果想看所有错误，可以去掉 if 判断
-                    if "路径格式不匹配" in msg or "复制异常" in msg:
-                        print(f"[!] {msg}")
+    print(f"[*] 开始多线程复制与校验 (线程数: {max_workers})...")
+    
+    with open(log_file_path, 'w', encoding='utf-8') as log_f:
+        log_f.write(f"=== 图片复制错误日志 ===\n")
+        log_f.write(f"源目录: {source_root}\n")
+        log_f.write(f"目标前缀: {target_prefix}\n")
+        log_f.write("="*50 + "\n\n")
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {
+                executor.submit(process_single_image_refined, path, src_root_path, tgt_prefix_path): path 
+                for path in unique_paths
+            }
+
+            for future in tqdm(as_completed(futures), total=len(unique_paths), desc="处理进度"):
+                path = futures[future]
+                try:
+                    status, msg = future.result()
+                except Exception as e:
+                    status = 'fail'
+                    msg = f"线程崩溃: {e}"
+
+                if status == 'success':
+                    success_count += 1
+                elif status == 'skip':
+                    skip_count += 1
+                elif status == 'fixed':
+                    fixed_count += 1
+                elif status == 'fail':
+                    fail_count += 1
+                    
+                    refs = image_ref_map.get(path, ["Unknown Reference"])
+                    ref_str = "\n\t".join(refs[:5])
+                    if len(refs) > 5:
+                        ref_str += f"\n\t... (还有 {len(refs)-5} 个引用)"
+                    
+                    log_entry = (
+                        f"--------------------------------------------------\n"
+                        f"[FAIL] 图片路径: {path}\n"
+                        f"[原因] {msg}\n"
+                        f"[影响的问题]:\n\t{ref_str}\n"
+                    )
+                    log_f.write(log_entry)
+                    log_f.flush()
 
     print("\n" + "="*30)
     print(f"任务完成 Summary:")
-    print(f"成功复制: {success_count}")
-    print(f"跳过 (已存在): {skip_count}")
+    print(f"新增复制: {success_count}")
+    print(f"跳过 (完好): {skip_count}")
+    print(f"修复 (损坏并覆盖): {fixed_count}")
     print(f"失败 (源缺失/错误): {fail_count}")
+    print(f"详细错误日志已保存至: {log_file_path}")
     print("="*30)
 
 
 if __name__ == "__main__":
-    # 1. 收集路径
-    paths = collect_image_paths(QUESTION_ROOT)
+    paths, ref_map = collect_image_paths_and_refs(QUESTION_ROOT)
     
     if not paths:
         print("[*] 没有找到需要复制的图片，或者目录为空，程序退出。")
     else:
-        # 2. 执行多线程复制
-        copy_images_multithread(paths, SOURCE_ROOT, TARGET_PREFIX, MAX_WORKERS)
+        copy_images_multithread(paths, ref_map, SOURCE_ROOT, TARGET_PREFIX, MAX_WORKERS, ERROR_LOG_FILE)