dataset_scripts/mjhq/preprocess.py

from tqdm import tqdm  # To measure processing time
from dataset.processor import ControlNetPreprocessor
from datasets import load_dataset
from PIL import Image
import os
import json
import random
import shutil


def create_dataset(
    preprocessor,
    input_dir,
    output_dir,
    samples_per_category=500,
):
    """
    Create a dataset for ControlNet from the specified dataset directory.
    Args:
        input_dir (str): Path to the input dataset directory.
        output_dir (str): Path to the output directory containing images and metadata.
    Returns:
        str: Path to the created dataset directory.
    """
    ORIGINAL_METADATA_FILE = "meta_data.json"
    CATEGORIES = [
        'animals', 'art', 'fashion', 'food', 'indoor',
        'landscape', 'logo', 'people', 'plants', 'vehicles'
    ]
    # Create output directories
    images_output_dir = os.path.join(output_dir, "images")
    controls_output_dir = os.path.join(output_dir, "controls")

    os.makedirs(output_dir, exist_ok=True)
    os.makedirs(images_output_dir, exist_ok=True)
    os.makedirs(controls_output_dir, exist_ok=True)

    # Prepare metadata
    metadata = []

    # read metainfo from dataset_dir
    try:
        with open(os.path.join(input_dir, ORIGINAL_METADATA_FILE), 'r', encoding='utf-8') as f:
                original_metadata = json.load(f)
    except FileNotFoundError:
        print(f"ERROR: Original metadata file not found at {os.path.join(input_dir, ORIGINAL_METADATA_FILE)}")
        print("Please ensure the path is correct and the file exists.")
        return
    except json.JSONDecodeError:
        print(f"ERROR: Could not decode JSON from {os.path.join(input_dir, ORIGINAL_METADATA_FILE)}. Is it a valid JSON file?")
        return
    
    # Iterate through categories to sample and copy images
    id = 0
    for category in CATEGORIES:
        print(f"\nProcessing category: {category}...")

        original_category_path = os.path.join(input_dir, category)

        if not os.path.isdir(original_category_path):
            print(f"  WARNING: Original category folder not found: {original_category_path}. Skipping.")
            continue

        # List all image files in the original category folder
        try:
            all_images_in_category = [
                f for f in os.listdir(original_category_path)
            ]
        except FileNotFoundError:
             print(f"  ERROR: Could not list files in {original_category_path}. Check permissions or path.")
             continue

        if not all_images_in_category:
            print(f"  WARNING: No image files found in {original_category_path} for category {category}. Skipping.")
            continue

        print(f"  Found {len(all_images_in_category)} images in original '{category}' folder.")

        # Randomly select SAMPLES_PER_CATEGORY image filenames
        if len(all_images_in_category) < samples_per_category:
            print(f"  WARNING: Category '{category}' has only {len(all_images_in_category)} images, "
                  f"which is less than the required {samples_per_category}. Taking all available images.")
            sampled_image_filenames_with_ext = all_images_in_category
        else:
            sampled_image_filenames_with_ext = random.sample(all_images_in_category, samples_per_category)

        print(f"  Sampling {len(sampled_image_filenames_with_ext)} images for '{category}'.")
        
        for img_filename_with_ext in sampled_image_filenames_with_ext:
            img_base_filename = os.path.splitext(img_filename_with_ext)[0]
            if img_base_filename in original_metadata:
                image_filename = f"image_{id:06d}.jpg"
                src_img_path = os.path.join(original_category_path, img_filename_with_ext)
                dst_img_path = os.path.join(images_output_dir, image_filename) # Destination is now the shared folder
                
                # Copy the image file to the single 'images' folder
                try:
                    shutil.copy2(src_img_path, dst_img_path) # copy2 preserves metadata
                except Exception as e:
                    print(f"    ERROR copying {src_img_path} to {dst_img_path}: {e}")
                    continue # Skip this image if copying fails
                
                # Save original image and control map
                control_map = preprocessor.process(image=Image.open(dst_img_path))
                control_filename = f"control_{id:06d}.jpg"
                control_map.save(os.path.join(controls_output_dir, control_filename))
                
                # Get the prompt from original metadata
                prompt = original_metadata[img_base_filename].get("prompt", "")
                
                # Add to metadata
                metadata.append(
                    {
                        "id": id,
                        "prompt": prompt,
                        "image": f"images/{image_filename}",
                        "control": f"controls/{control_filename}",
                    }
                )
                id += 1
            else:
                print(f"  WARNING: Metadata key '{img_base_filename}' (from file '{img_filename_with_ext}') "
                      f"not found in original_metadata.json. Skipping this image.")

    # 4. Save new metadata
    # Save metadata
    metadata_path = os.path.join(output_dir, "metadata.json")
    with open(metadata_path, "w") as f:
        json.dump(metadata, f, indent=2)
    print(f"Dataset created at: {output_dir}")
    print(f"Total processed samples: {len(metadata)}")

    return output_dir
    
def parse_args():
    import argparse
    # Set up command line arguments
    parser = argparse.ArgumentParser(description="Create ControlNet dataset from datasets")
    parser.add_argument(
        "--cn_type",
        type=str,
        default="canny",
        choices=["canny", "depth"],
        help="Type of control map to generate",
    )
    parser.add_argument(
        "--enable_blur",
        action="store_true",
        help="Enable Gaussian blur for Canny edge detection",
    )
    parser.add_argument(
        "--dataset",
        type=str,
        default="MJHQ-30K",
        help="Dataset to use (default: MJHQ-30K)",
    )
    parser.add_argument(
        "--dataset_dir",
        type=str,
        default="../dataset",
        help="Dataset to use (default: COCO-Caption2017)",
    )
    parser.add_argument(
        "--output_dir",
        type=str,
        default="../dataset/controlnet_datasets",
        help="Directory to save the processed dataset",
    )
    parser.add_argument(
        "--blur_kernel_size",
        type=int,
        default=3,
        help="Kernel size used to blur the image before Canny edge detection (must be odd)",
    )
    parser.add_argument("--enable_no_prompt", action="store_true")
    return parser.parse_args()
 


if __name__ == "__main__":
    args = parse_args()
    # Initialize preprocessor
    preprocessor = ControlNetPreprocessor(
        enable_blur=args.enable_blur, blur_kernel_size=args.blur_kernel_size,cn_type=args.cn_type
    )
    # Create anno dataset
    control_dataset_dir = create_dataset(
        preprocessor=preprocessor,
        input_dir=os.path.join(args.dataset_dir, args.dataset),
        output_dir=os.path.join(args.output_dir, f"{args.dataset}-{args.cn_type}"),
        samples_per_category=500,  # Number of samples per category
    )

    print(f"\nControlNet dataset created at: {control_dataset_dir}")
    print("Done!")