lama

1
#!/usr/bin/env python3
2

3
import glob
4
import os
5
import shutil
6
import traceback
7

8
import PIL.Image as Image
9
import numpy as np
10
from joblib import Parallel, delayed
11

12
from saicinpainting.evaluation.masks.mask import SegmentationMask, propose_random_square_crop
13
from saicinpainting.evaluation.utils import load_yaml, SmallMode
14
from saicinpainting.training.data.masks import MixedMaskGenerator
15

16

17
class MakeManyMasksWrapper:
18
    def __init__(self, impl, variants_n=2):
19
        self.impl = impl
20
        self.variants_n = variants_n
21

22
    def get_masks(self, img):
23
        img = np.transpose(np.array(img), (2, 0, 1))
24
        return [self.impl(img)[0] for _ in range(self.variants_n)]
25

26

27
def process_images(src_images, indir, outdir, config):
28
    if config.generator_kind == 'segmentation':
29
        mask_generator = SegmentationMask(**config.mask_generator_kwargs)
30
    elif config.generator_kind == 'random':
31
        variants_n = config.mask_generator_kwargs.pop('variants_n', 2)
32
        mask_generator = MakeManyMasksWrapper(MixedMaskGenerator(**config.mask_generator_kwargs),
33
                                              variants_n=variants_n)
34
    else:
35
        raise ValueError(f'Unexpected generator kind: {config.generator_kind}')
36

37
    max_tamper_area = config.get('max_tamper_area', 1)
38

39
    for infile in src_images:
40
        try:
41
            file_relpath = infile[len(indir):]
42
            img_outpath = os.path.join(outdir, file_relpath)
43
            os.makedirs(os.path.dirname(img_outpath), exist_ok=True)
44

45
            image = Image.open(infile).convert('RGB')
46

47
            # scale input image to output resolution and filter smaller images
48
            if min(image.size) < config.cropping.out_min_size:
49
                handle_small_mode = SmallMode(config.cropping.handle_small_mode)
50
                if handle_small_mode == SmallMode.DROP:
51
                    continue
52
                elif handle_small_mode == SmallMode.UPSCALE:
53
                    factor = config.cropping.out_min_size / min(image.size)
54
                    out_size = (np.array(image.size) * factor).round().astype('uint32')
55
                    image = image.resize(out_size, resample=Image.BICUBIC)
56
            else:
57
                factor = config.cropping.out_min_size / min(image.size)
58
                out_size = (np.array(image.size) * factor).round().astype('uint32')
59
                image = image.resize(out_size, resample=Image.BICUBIC)
60

61
            # generate and select masks
62
            src_masks = mask_generator.get_masks(image)
63

64
            filtered_image_mask_pairs = []
65
            for cur_mask in src_masks:
66
                if config.cropping.out_square_crop:
67
                    (crop_left,
68
                     crop_top,
69
                     crop_right,
70
                     crop_bottom) = propose_random_square_crop(cur_mask,
71
                                                               min_overlap=config.cropping.crop_min_overlap)
72
                    cur_mask = cur_mask[crop_top:crop_bottom, crop_left:crop_right]
73
                    cur_image = image.copy().crop((crop_left, crop_top, crop_right, crop_bottom))
74
                else:
75
                    cur_image = image
76

77
                if len(np.unique(cur_mask)) == 0 or cur_mask.mean() > max_tamper_area:
78
                    continue
79

80
                filtered_image_mask_pairs.append((cur_image, cur_mask))
81

82
            mask_indices = np.random.choice(len(filtered_image_mask_pairs),
83
                                            size=min(len(filtered_image_mask_pairs), config.max_masks_per_image),
84
                                            replace=False)
85

86
            # crop masks; save masks together with input image
87
            mask_basename = os.path.join(outdir, os.path.splitext(file_relpath)[0])
88
            for i, idx in enumerate(mask_indices):
89
                cur_image, cur_mask = filtered_image_mask_pairs[idx]
90
                cur_basename = mask_basename + f'_crop{i:03d}'
91
                Image.fromarray(np.clip(cur_mask * 255, 0, 255).astype('uint8'),
92
                                mode='L').save(cur_basename + f'_mask{i:03d}.png')
93
                cur_image.save(cur_basename + '.png')
94
        except KeyboardInterrupt:
95
            return
96
        except Exception as ex:
97
            print(f'Could not make masks for {infile} due to {ex}:\n{traceback.format_exc()}')
98

99

100
def main(args):
101
    if not args.indir.endswith('/'):
102
        args.indir += '/'
103

104
    os.makedirs(args.outdir, exist_ok=True)
105

106
    config = load_yaml(args.config)
107

108
    in_files = list(glob.glob(os.path.join(args.indir, '**', f'*.{args.ext}'), recursive=True))
109
    if args.n_jobs == 0:
110
        process_images(in_files, args.indir, args.outdir, config)
111
    else:
112
        in_files_n = len(in_files)
113
        chunk_size = in_files_n // args.n_jobs + (1 if in_files_n % args.n_jobs > 0 else 0)
114
        Parallel(n_jobs=args.n_jobs)(
115
            delayed(process_images)(in_files[start:start+chunk_size], args.indir, args.outdir, config)
116
            for start in range(0, len(in_files), chunk_size)
117
        )
118

119

120
if __name__ == '__main__':
121
    import argparse
122

123
    aparser = argparse.ArgumentParser()
124
    aparser.add_argument('config', type=str, help='Path to config for dataset generation')
125
    aparser.add_argument('indir', type=str, help='Path to folder with images')
126
    aparser.add_argument('outdir', type=str, help='Path to folder to store aligned images and masks to')
127
    aparser.add_argument('--n-jobs', type=int, default=0, help='How many processes to use')
128
    aparser.add_argument('--ext', type=str, default='jpg', help='Input image extension')
129

130
    main(aparser.parse_args())
131