Upload 2 files

Downloads.7z

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de411830ffafad5c374641e688687e9b4569f715376b949275e1739b40e2ce27
+size 2228098

并行优化版本(1) (1).py

@@ -0,0 +1,413 @@
+import argparse
+import shutil
+import av
+import os
+import cv2
+import sys
+import time
+import multiprocessing
+import tkinter as tk
+from tkinter import filedialog
+from concurrent.futures import ThreadPoolExecutor
+from PIL import Image
+import numpy as np
+from collections import defaultdict
+from waifuc.action import MinSizeFilterAction, PersonSplitAction
+from waifuc.export import SaveExporter, TextualInversionExporter
+from waifuc.source import LocalSource
+from tqdm import tqdm
+import logging
+
+# 配置日志
+logging.basicConfig(filename='video_image_processing.log', level=logging.INFO,
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+
+
+def select_folder():
+    """
+    弹出文件夹选择对话框，返回选择的文件夹路径。
+    """
+    root = tk.Tk()
+    root.withdraw()  # 隐藏主窗口
+    folder_path = filedialog.askdirectory(title="选择视频文件夹")
+    return folder_path
+
+
+def create_output_folder(folder_path, extra_name):
+    """
+    创建输出文件夹，文件夹名称为原名称加上额外的后缀。
+
+    参数：
+        folder_path (str): 原文件夹路径。
+        extra_name (str): 要添加到文件夹名称后的字符串。
+
+    返回：
+        str: 新创建的文件夹路径。
+    """
+    folder_name = os.path.basename(folder_path)
+    new_folder_name = f"{folder_name}{extra_name}"
+    new_folder_path = os.path.join(folder_path, new_folder_name)
+    os.makedirs(new_folder_path, exist_ok=True)
+    return new_folder_path
+
+
+def find_video_files(folder_path):
+    """
+    在指定文件夹及其子文件夹中查找所有视频文件。
+
+    参数：
+        folder_path (str): 文件夹路径。
+
+    返回：
+        list: 视频文件的完整路径列表。
+    """
+    video_extensions = ('.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv')
+    video_files = []
+    for root, dirs, files in os.walk(folder_path):
+        for file in files:
+            if file.lower().endswith(video_extensions):
+                video_files.append(os.path.join(root, file))
+    return video_files
+
+
+def process_video(video_file, new_folder_path, frame_step=5):
+    """
+    处理视频文件，提取帧，计算哈希和清晰度，保存符合条件的帧。
+
+    参数：
+        video_file (str): 视频文件路径。
+        new_folder_path (str): 保存提取帧的文件夹路径。
+        frame_step (int): 帧步长，每隔多少帧处理一次。
+    """
+    def compute_phash(image):
+        resized = cv2.resize(image, (32, 32), interpolation=cv2.INTER_AREA)
+        gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
+        dct = cv2.dct(np.float32(gray))
+        dct_low = dct[:8, :8]
+        med = np.median(dct_low)
+        return (dct_low > med).flatten()
+
+    def compute_sharpness(image):
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        # 使用 Sobel 算子计算梯度
+        grad_x = cv2.Sobel(gray, cv2.CV_16S, 1, 0)
+        grad_y = cv2.Sobel(gray, cv2.CV_16S, 0, 1)
+        # 计算梯度的绝对值和
+        sharpness = cv2.mean(np.abs(grad_x) + np.abs(grad_y))[0]
+        return sharpness
+
+    def save_frame(image, frame_count):
+        image_name = f'{os.path.splitext(os.path.basename(video_file))[0]}-{frame_count:08d}.jpg'
+        image_path = os.path.join(new_folder_path, image_name)
+        cv2.imwrite(image_path, image, [cv2.IMWRITE_JPEG_QUALITY, 90])
+
+    # 打开视频文件
+    container = av.open(video_file)
+    video = container.streams.video[0]
+
+    # 尝试启用硬件加速
+    try:
+        video.codec_context.options = {'hwaccel': 'auto'}
+    except Exception as e:
+        print(f"无法启用硬件加速: {e}")
+        logging.warning(f"无法启用硬件加速: {e}")
+
+    start_time = time.time()
+    frame_count = 0
+    saved_count = 0
+    sharpness_threshold = 15  # 清晰度阈值
+
+    reference_image = None
+    reference_phash = None
+    reference_sharpness = None
+    reference_count = 0
+
+    for frame in tqdm(container.decode(video=0), desc=f"处理视频 {os.path.basename(video_file)}"):
+        if frame_count % frame_step != 0:
+            frame_count += 1
+            continue  # 跳过不需要处理的帧
+
+        image = frame.to_ndarray(format='bgr24')
+        phash = compute_phash(image)
+        sharpness = compute_sharpness(image)
+
+        if sharpness < sharpness_threshold:
+            frame_count += 1
+            continue  # 跳过模糊帧
+
+        if reference_image is None:
+            # 初始化参考帧
+            reference_image = image
+            reference_phash = phash
+            reference_sharpness = sharpness
+            reference_count = frame_count
+        else:
+            hamming_dist = np.sum(phash != reference_phash)
+            if hamming_dist > 10:
+                # 与参考帧差异较大，保存参考���
+                save_frame(reference_image, reference_count)
+                saved_count += 1
+                # 更新参考帧
+                reference_image = image
+                reference_phash = phash
+                reference_sharpness = sharpness
+                reference_count = frame_count
+            else:
+                # 与参考帧相似，比较清晰度
+                if sharpness > reference_sharpness:
+                    # 当前帧更清晰，更新参考帧
+                    reference_image = image
+                    reference_phash = phash
+                    reference_sharpness = sharpness
+                    reference_count = frame_count
+                # 否则，保留原参考帧
+
+        frame_count += 1
+
+    # 保存最后的参考帧
+    if reference_image is not None:
+        save_frame(reference_image, reference_count)
+        saved_count += 1
+
+    total_time = time.time() - start_time
+    average_fps = frame_count / total_time if total_time > 0 else 0
+    print(f'\n{os.path.basename(video_file)} 处理完成: 总共 {frame_count} 帧, 保存 {saved_count} 帧, 平均 {average_fps:.2f} 帧/秒')
+    logging.info(f'{os.path.basename(video_file)} 处理完成: 总共 {frame_count} 帧, 保存 {saved_count} 帧, 平均 {average_fps:.2f} 帧/秒')
+
+
+def process_images_folder(new_folder_path):
+    """
+    处理保存的图像文件，去除相似的重复图片，仅保留最清晰的。
+
+    参数：
+        new_folder_path (str): 图像文件夹路径。
+
+    返回：
+        set: 保留的图像文件路径集合。
+    """
+    def get_image_files(folder_path):
+        image_files = [os.path.join(folder_path, f) for f in os.listdir(folder_path)
+                       if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+        print(f'总共找到 {len(image_files)} 张图片')
+        logging.info(f'总共找到 {len(image_files)} 张图片')
+        return image_files
+
+    def process_images(image_files):
+        def compute_phash(image):
+            resized = cv2.resize(image, (32, 32), interpolation=cv2.INTER_AREA)
+            gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
+            dct = cv2.dct(np.float32(gray))
+            dct_low = dct[:8, :8]
+            med = np.median(dct_low)
+            return (dct_low > med).flatten()
+
+        def compute_sharpness(image):
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            return cv2.Laplacian(gray, cv2.CV_64F).var()
+
+        def process_single_image(image_path):
+            image = cv2.imread(image_path)
+            if image is None:
+                error_message = f"无法读取图像文件 {image_path}"
+                print(f"警告：{error_message}")
+                logging.warning(error_message)
+                return None
+            try:
+                phash = compute_phash(image)
+                sharpness = compute_sharpness(image)
+                return image_path, phash, sharpness
+            except Exception as e:
+                error_message = f"处理图像时出错 {image_path}: {e}"
+                print(f"警告：{error_message}")
+                logging.warning(error_message)
+                return None
+
+        image_data = {}
+        start_time = time.time()
+        with ThreadPoolExecutor() as executor:
+            futures = [executor.submit(process_single_image, img) for img in image_files]
+            for future in tqdm(futures, desc="计算哈希和清晰度", unit="张"):
+                result = future.result()
+                if result is not None:
+                    image_path, phash, sharpness = result
+                    image_data[image_path] = {'phash': phash, 'sharpness': sharpness}
+
+        elapsed_time = time.time() - start_time
+        print(f'\n图片处理完成，耗时 {elapsed_time:.2f} 秒')
+        logging.info(f'图片处理完成，耗时 {elapsed_time:.2f} 秒')
+        return image_data
+
+    def compare_images(image_data):
+        similar_groups = {}
+        hash_buckets = defaultdict(list)
+        # 将哈希值转换为字符串，并取前几位作为桶的键
+        for image_path, data in image_data.items():
+            hash_str = ''.join(data['phash'].astype(int).astype(str))
+            bucket_key = hash_str[:16]  # 取前16位作为桶的键，可根据需要调整
+            hash_buckets[bucket_key].append((image_path, data))
+
+        total_buckets = len(hash_buckets)
+        print(f"总共划分为 {total_buckets} 个哈希桶")
+        logging.info(f"总共划分为 {total_buckets} 个哈希桶")
+
+        # 遍历每个桶，比较桶内的图片
+        for bucket_key, bucket in tqdm(hash_buckets.items(), desc="比较哈希桶", unit="桶"):
+            paths = [item[0] for item in bucket]
+            hashes = np.array([item[1]['phash'] for item in bucket])
+            for i in range(len(paths)):
+                for j in range(i + 1, len(paths)):
+                    dist = np.sum(hashes[i] != hashes[j])
+                    if dist <= 10:  # 阈值，可根据需要调整
+                        similar_groups.setdefault(paths[i], []).append(paths[j])
+
+        return similar_groups
+
+    def select_images_to_keep(similar_groups, image_data):
+        to_keep = set()
+        processed_groups = set()
+        for group_key, group in similar_groups.items():
+            if group_key in processed_groups:
+                continue
+            group_with_key = [group_key] + group
+            sharpest = max(group_with_key, key=lambda x: image_data[x]['sharpness'])
+            to_keep.add(sharpest)
+            processed_groups.update(group_with_key)
+        # 将不在任何相似组中的图片也加入保留列表
+        all_images = set(image_data.keys())
+        images_in_groups = set().union(*[set([k] + v) for k, v in similar_groups.items()])
+        images_not_in_groups = all_images - images_in_groups
+        to_keep.update(images_not_in_groups)
+        return to_keep
+
+    def delete_duplicate_images(similar_groups, to_keep):
+        deleted_count = 0
+        to_delete = set()
+
+        # 收集所有需要删除的图片
+        for group_key, similar_images in similar_groups.items():
+            group_with_key = [group_key] + similar_images
+            for image_path in group_with_key:
+                if image_path not in to_keep:
+                    to_delete.add(image_path)
+
+        total_to_delete = len(to_delete)
+
+        # 删除图片
+        for image_path in tqdm(to_delete, desc="删除重复图片", unit="张"):
+            try:
+                os.remove(image_path)
+                deleted_count += 1
+            except Exception as e:
+                print(f"\n无法删除 {image_path}: {e}")
+                logging.error(f"无法删除 {image_path}: {e}")
+
+        print(f'\n去重完成，保留 {len(to_keep)} 张图片，成功删除 {deleted_count} 张重复图片')
+        logging.info(f'去重完成，保留 {len(to_keep)} 张图片，成功删除 {deleted_count} 张重复图片')
+
+        return deleted_count
+
+    # 开始执行去重流程
+    image_files = get_image_files(new_folder_path)
+    image_data = process_images(image_files)
+    similar_groups = compare_images(image_data)
+    to_keep = select_images_to_keep(similar_groups, image_data)
+    deleted_count = delete_duplicate_images(similar_groups, to_keep)
+
+
+def waifuc_split(new_folder_path, split_path):
+    """
+    使用 waifuc 库对图像进行分割，提取人物部分。
+
+    参数：
+        new_folder_path (str): 原始图像文件夹路径。
+        split_path (str): 分割后图像的保存路径。
+    """
+    # 直接使用目录路径初始化 LocalSource
+    s = LocalSource(new_folder_path)
+    s = s.attach(
+        PersonSplitAction(), MinSizeFilterAction(300),
+    )
+    s.export(SaveExporter(split_path, no_meta=True))
+
+
+def process_split_images(new_folder_path, split_path):
+    """
+    将没有检测到人物的原始图像移动到指定的无人文件夹。
+
+    参数：
+        new_folder_path (str): 原始图像文件夹路径。
+        split_path (str): 分割后图像的保存路径。
+    """
+    nohuman_path = create_output_folder(new_folder_path, "-nohuman")
+
+    # 获取去重后的原始图片列表
+    original_images = [f for f in os.listdir(new_folder_path)
+                       if os.path.isfile(os.path.join(new_folder_path, f)) and
+                       f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))]
+
+    split_images = [f for f in os.listdir(split_path)
+                    if f.lower().endswith(('.jpg', '.jpeg', '.png', '.webp'))]
+
+    total_images = len(original_images)
+    moved_count = 0
+
+    for original_image in tqdm(original_images, desc="处理无人图片", unit="张"):
+        base_name = os.path.splitext(original_image)[0]
+        has_person = any(split_image.startswith(base_name + '_person') for split_image in split_images)
+
+        if not has_person:
+            source_path = os.path.join(new_folder_path, original_image)
+            dest_path = os.path.join(nohuman_path, original_image)
+            try:
+                shutil.move(source_path, dest_path)
+                moved_count += 1
+            except Exception as e:
+                print(f"\n无法移动 {source_path}: {e}")
+                logging.error(f"无法移动 {source_path}: {e}")
+
+    print(f'\n处理完成。总共处理 {total_images} 张图片, 移动了 {moved_count} 张无人图片到 {nohuman_path}')
+    logging.info(f'处理完成。总共处理 {total_images} 张图片, 移动了 {moved_count} 张无人图片到 {nohuman_path}')
+
+
+def main():
+    """
+    主函数，执行整个处理流程。
+    """
+    folder_path = select_folder()
+    if not folder_path:
+        print("未选择文件夹，程序退出。")
+        logging.error("未选择文件夹，程序退出。")
+        return
+
+    video_files = find_video_files(folder_path)
+    if not video_files:
+        print("所选文件夹中未找到视频文件，程序退出。")
+        logging.error("所选文件夹中未找到视频文件，程序退出。")
+        return
+
+    # 创建保存提取帧的文件夹
+    new_folder_path = create_output_folder(folder_path, "-Eng_SS")
+
+    # 处理每个视频文件
+    for video_file in video_files:
+        print(f"开始处理视频文件: {video_file}")
+        logging.info(f"开始处理视频文件: {video_file}")
+        process_video(video_file, new_folder_path, frame_step=5)  # 设置帧步长
+
+    # 去除相似的重复图片（第一次）
+    process_images_folder(new_folder_path)
+    # 去除相似的重复图片（第二次）
+    process_images_folder(new_folder_path)
+
+    # 创建保存分割后图像的文件夹
+    split_path = create_output_folder(new_folder_path, "-split")
+
+    # 使用 waifuc 库进行人物分割
+    waifuc_split(new_folder_path, split_path)
+
+    # 移动没有检测到人物的图像到无人文件夹
+    process_split_images(new_folder_path, split_path)
+
+
+if __name__ == "__main__":
+    main()