scripts/extract_subimages_fixed_multithreaded.py

import argparse
import cv2
import numpy as np
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
from basicsr.utils import scandir
from os import path as osp
from tqdm import tqdm
import logging

# Настройка логирования для отслеживания ошибок
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def worker(path, opt):
    """Worker for each thread.

    Args:
        path (str): Image path.
        opt (dict): Configuration dict. It contains:
            crop_size (int): Crop size.
            step (int): Step for overlapped sliding window.
            thresh_size (int): Threshold size. Patches whose size is lower than thresh_size will be dropped.
            save_folder (str): Path to save folder.
            compression_level (int): for cv2.IMWRITE_PNG_COMPRESSION.

    Returns:
        tuple: (status, img_name, count, message) - status can be 'processed', 'skipped', 'error', or 'too_small'
    """
    crop_size = opt['crop_size']
    step = opt['step']
    thresh_size = opt['thresh_size']
    save_folder = opt['save_folder']
    img_name, extension = osp.splitext(osp.basename(path))

    # remove the x2, x3, x4 and x8 in the filename for DIV2K
    img_name = img_name.replace('x2', '').replace('x3', '').replace('x4', '').replace('x8', '')

    try:
        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)

        # Проверим, что изображение было успешно загружено
        if img is None:
            logger.warning(f"Could not read image: {path}")
            return ('error', img_name, 0, f"Could not read image: {path}")

        h, w = img.shape[0:2]

        # Проверим минимальный размер изображения
        if h < crop_size or w < crop_size:
            logger.warning(f"Image {path} is smaller than crop size: ({h}, {w}) < {crop_size}")
            return ('too_small', img_name, 0, f"Image too small: ({h}, {w}) < {crop_size}")

        h_space = np.arange(0, h - crop_size + 1, step)
        if h - (h_space[-1] + crop_size) > thresh_size:
            h_space = np.append(h_space, h - crop_size)
        w_space = np.arange(0, w - crop_size + 1, step)
        if w - (w_space[-1] + crop_size) > thresh_size:
            w_space = np.append(w_space, w - crop_size)

        # Обрабатываем патчи, пропуская уже существующие
        saved_count = 0
        skipped_count = 0
        index = 0
        for x in h_space:
            for y in w_space:
                index += 1
                output_path = osp.join(save_folder, f'{img_name}_s{index:03d}{extension}')
                if osp.exists(output_path):
                    skipped_count += 1
                    continue
                cropped_img = img[x:x + crop_size, y:y + crop_size, ...]
                cropped_img = np.ascontiguousarray(cropped_img)
                cv2.imwrite(
                    output_path, cropped_img,
                    [cv2.IMWRITE_PNG_COMPRESSION, opt['compression_level']])
                saved_count += 1

        total_patches = saved_count + skipped_count
        if saved_count == 0 and skipped_count > 0:
            return ('skipped', img_name, total_patches, f"All {total_patches} patches already exist")
        return ('processed', img_name, total_patches, f"Saved {saved_count}, skipped {skipped_count}")

    except Exception as e:
        logger.error(f"Error processing image {path}: {e}")
        return ('error', img_name, 0, str(e))


def extract_subimages(opt):
    """Crop images to subimages.

    Args:
        opt (dict): Configuration dict. It contains:
            input_folder (str): Path to the input folder.
            save_folder (str): Path to save folder.
            n_thread (int): Thread number.
    """
    input_folder = opt['input_folder']
    save_folder = opt['save_folder']
    if not osp.exists(save_folder):
        os.makedirs(save_folder)
        print(f'mkdir {save_folder} ...')
    else:
        print(f'Папка {save_folder} уже существует. Продолжаем обработку...')

    # scan all images
    img_list = list(scandir(input_folder, full_path=True))

    if not img_list:
        print('Изображения не найдены')
        return

    # Используем ThreadPoolExecutor для параллельной обработки
    processed = 0
    skipped = 0
    errors = 0
    too_small = 0
    total_patches = 0

    with ThreadPoolExecutor(max_workers=opt['n_thread']) as executor:
        futures = {
            executor.submit(worker, path, opt): path
            for path in img_list
        }

        with tqdm(total=len(img_list), desc='Извлечение подизображений', unit='img') as pbar:
            for future in as_completed(futures):
                try:
                    status, img_name, count, message = future.result()
                    if status == 'skipped':
                        skipped += 1
                        total_patches += count
                    elif status == 'processed':
                        processed += 1
                        total_patches += count
                    elif status == 'too_small':
                        too_small += 1
                    else:  # error
                        errors += 1
                        tqdm.write(f'Ошибка: {img_name} - {message}')
                    pbar.set_postfix({
                        'обработано': processed,
                        'пропущено': skipped,
                        'маленьких': too_small,
                        'ошибок': errors,
                        'патчей': total_patches
                    })
                except Exception as e:
                    path = futures[future]
                    errors += 1
                    tqdm.write(f'Ошибка при обработке {path}: {e}')
                    pbar.set_postfix({
                        'обработано': processed,
                        'пропущено': skipped,
                        'маленьких': too_small,
                        'ошибок': errors,
                        'патчей': total_patches
                    })
                finally:
                    pbar.update(1)

    print(f'Все процессы завершены. Обработано: {processed}, пропущено: {skipped}, '
          f'маленьких: {too_small}, ошибок: {errors}, всего патчей: {total_patches}')


def main(args):
    """A multi-thread tool to crop large images to sub-images for faster IO.

    opt (dict): Configuration dict. It contains:
        n_thread (int): Thread number.
        compression_level (int):  CV_IMWRITE_PNG_COMPRESSION from 0 to 9. A higher value means a smaller size
            and longer compression time. Use 0 for faster CPU decompression. Default: 3, same in cv2.
        input_folder (str): Path to the input folder.
        save_folder (str): Path to save folder.
        crop_size (int): Crop size.
        step (int): Step for overlapped sliding window.
        thresh_size (int): Threshold size. Patches whose size is lower than thresh_size will be dropped.

    Usage:
        For each folder, run this script.
        Typically, there are GT folder and LQ folder to be processed for DIV2K dataset.
        After process, each sub_folder should have the same number of subimages.
        Remember to modify opt configurations according to your settings.
    """

    opt = {}
    opt['n_thread'] = args.n_thread
    opt['compression_level'] = args.compression_level
    opt['input_folder'] = args.input
    opt['save_folder'] = args.output
    opt['crop_size'] = args.crop_size
    opt['step'] = args.step
    opt['thresh_size'] = args.thresh_size
    extract_subimages(opt)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--input', type=str, default='datasets/DF2K/DF2K_HR', help='Input folder')
    parser.add_argument('--output', type=str, default='datasets/DF2K/DF2K_HR_sub', help='Output folder')
    parser.add_argument('--crop_size', type=int, default=480, help='Crop size')
    parser.add_argument('--step', type=int, default=240, help='Step for overlapped sliding window')
    parser.add_argument(
        '--thresh_size',
        type=int,
        default=0,
        help='Threshold size. Patches whose size is lower than thresh_size will be dropped.')
    parser.add_argument('--n_thread', type=int, default=None, help='Thread number (default: CPU count)')
    parser.add_argument('--compression_level', type=int, default=3, help='Compression level')
    args = parser.parse_args()

    if args.n_thread is None:
        import multiprocessing
        args.n_thread = multiprocessing.cpu_count()

    main(args)