generate_occluded_imagenet_single_occluder.py

import os
import random
import numpy as np
import pandas as pd
from PIL import Image
from torchvision import datasets, transforms, io
import torch


def get_random_texture(dataset_occluder):
 index = random.randint(0, len(dataset_occluder) - 1)
 texture_path, texture_class_index = dataset_occluder.imgs[index]
 texture_class = dataset_occluder.classes[texture_class_index]

 # Load the texture with the alpha channel
 texture = io.read_image(texture_path, mode=io.image.ImageReadMode.RGB_ALPHA)

 return texture, texture_class

def resize_occluder(occluder_pil, target_area, image_width, image_height):
 alpha = np.array(occluder_pil.getchannel('A'))
 non_transparent_area = np.count_nonzero(alpha > 0)

 area_scale_factor = target_area / non_transparent_area

 width_scale_factor = np.sqrt(area_scale_factor * (occluder_pil.width / occluder_pil.height))
 height_scale_factor = np.sqrt(area_scale_factor * (occluder_pil.height / occluder_pil.width))

 new_width = occluder_pil.width * width_scale_factor
 new_height = occluder_pil.height * height_scale_factor

 resized_occluder = occluder_pil.resize((int(new_width), int(new_height)), Image.LANCZOS)

 return resized_occluder

def randomly_rotate_occluder(occluder_pil):
 angle = random.uniform(-180, 180)
 return occluder_pil.rotate(angle, resample=Image.BICUBIC, expand=True)

def try_rotations(occluder_pil, image_pil, target_area):
 best_occluder = None
 best_area = 0
 best_pos = None
 for _ in range(10):
 rotated = randomly_rotate_occluder(occluder_pil)
 resized = resize_occluder(rotated, target_area, image_pil.width, image_pil.height)
 if resized.width > image_pil.width or resized.height > image_pil.height:
 pos = (image_pil.width // 2 - resized.width // 2, 
 image_pil.height // 2 - resized.height // 2)
 else:
 max_x = max(0, image_pil.width - resized.width)
 max_y = max(0, image_pil.height - resized.height)
 pos = (random.randint(0, max_x), random.randint(0, max_y))

 mask = Image.new('1', image_pil.size)
 mask.paste(resized.getchannel('A'), pos, resized.getchannel('A'))
 area = np.count_nonzero(np.array(mask))

 if area > best_area:
 best_area = area
 best_occluder = resized
 best_pos = pos
 return best_occluder, best_pos


def occlude_image(image, occluder_tensor, percentage_occlusion, occluded_dir, img_name):
 occluder_pil = transforms.ToPILImage(mode='RGBA')(occluder_tensor)
 image_pil = transforms.ToPILImage()(image)

 target_area = image_pil.width * image_pil.height * percentage_occlusion
 occluder_pil, pos = try_rotations(occluder_pil, image_pil, target_area)

 image_pil.paste(occluder_pil, pos, occluder_pil)
 image_with_occluder_tensor = transforms.ToTensor()(image_pil)

 occluder_alpha = occluder_pil.getchannel('A')
 binary_mask = Image.new('1', image_pil.size)
 binary_mask.paste(occluder_alpha, pos, occluder_alpha)

 mask_array = np.array(binary_mask)
 mask_path = os.path.join(occluded_dir, f"{img_name}_mask.npy")
 np.save(mask_path, mask_array)

 return image_with_occluder_tensor, mask_path, pos


def rebuild_display_mask(image_path, mask_path):
 image_pil = Image.open(image_path)
 binary_mask = Image.new('1', image_pil.size)

 mask_array = np.load(mask_path)
 mask_indices = np.transpose(np.nonzero(mask_array))

 for i, j in mask_indices:
 binary_mask.putpixel((j, i), 1)

 binary_mask.show()


def build_dataset(data_path, transform):
 dataset = datasets.ImageFolder(data_path, transform=transform)
 nb_classes = len(dataset.classes)
 return dataset, nb_classes

def build_transform():
 t = []
 t.append(transforms.ToTensor())
 return transforms.Compose(t)

def main():
 data_dir = 'imagenet1'
 texture_dir = 'occluders_segmented'
 occluded_data_dir = 'imagenet_occluded'

 transform = build_transform()
 dataset, nb_classes = build_dataset(data_dir, transform)
 dataset_occluder, _ = build_dataset(texture_dir, transform)

 occlusion_info = pd.DataFrame(columns=["image_name", "class_name", "occluder_class",
 "percentage_occlusion", "mask", "pos"])

 for idx in range(len(dataset)):
 image, label = dataset[idx]
 category = dataset.classes[label]

 in_dir = os.path.join(data_dir, category)
 occluded_dir = os.path.join(occluded_data_dir, category)

 os.makedirs(occluded_dir, exist_ok=True)

 img_name = dataset.imgs[idx][0].split('/')[-1].split('.')[0]

 occluder_tensor, occluder_class = get_random_texture(dataset_occluder)
 occluded_image, mask_path, pos = occlude_image(image, occluder_tensor, 0.3, occluded_dir, img_name)

 mask_array = np.load(mask_path)
 actual_percentage_occlusion = np.count_nonzero(mask_array) / (image.shape[1] * image.shape[2])

 occluded_image_path = os.path.join(occluded_dir, f"{img_name}_occluded.png")
 transforms.ToPILImage()(occluded_image).save(occluded_image_path)

 new_row = pd.DataFrame({
 "image_name": [f"{img_name}_occluded.png"],
 "class_name": [category],
 "occluder_class": [occluder_class],
 "percentage_occlusion": [actual_percentage_occlusion],
 "mask": [mask_path],
 "pos": [pos]
 })

 occlusion_info = pd.concat([occlusion_info, new_row], ignore_index=True)

 occlusion_info.to_csv(os.path.join(occluded_data_dir, "occlusion_info.csv"), index=False)

if __name__ == "__main__":
 main()