File size: 6,522 Bytes
c6d57da |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 |
from argparse import ArgumentParser
import time
import numpy as np
import PIL
import PIL.Image
import os
import scipy
import scipy.ndimage
import insightface
import multiprocessing as mp
import math
def get_landmark(filepath, face_detector):
"""get landmark with InsightFace
:return: np.array shape=(68, 2)
"""
if isinstance(filepath, str):
img = PIL.Image.open(filepath)
img = np.array(img)
else:
img = filepath
faces = face_detector.get(img)
if len(faces) == 0:
print('Error: no face detected!')
return None
# Assume the first detected face is the target
face = faces[0]
lm = face.landmark_2d_106[:, :2] # Use 106-point landmarks
return lm
def align_face(filepath, face_detector):
"""
:param filepath: str
:return: PIL Image
"""
lm = get_landmark(filepath, face_detector)
if lm is None:
return None
# Use the same landmark indices as before
lm_eye_left = lm[36: 42] # left-clockwise
lm_eye_right = lm[42: 48] # left-clockwise
lm_mouth_outer = lm[48: 60] # left-clockwise
# Calculate auxiliary vectors.
eye_left = np.mean(lm_eye_left, axis=0)
eye_right = np.mean(lm_eye_right, axis=0)
eye_avg = (eye_left + eye_right) * 0.5
eye_to_eye = eye_right - eye_left
mouth_left = lm_mouth_outer[0]
mouth_right = lm_mouth_outer[6]
mouth_avg = (mouth_left + mouth_right) * 0.5
eye_to_mouth = mouth_avg - eye_avg
# Choose oriented crop rectangle.
x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]
x /= np.hypot(*x)
x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)
y = np.flipud(x) * [-1, 1]
c = eye_avg + eye_to_mouth * 0.1
quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])
qsize = np.hypot(*x) * 2
# read image
if isinstance(filepath, str):
img = PIL.Image.open(filepath)
else:
img = PIL.Image.fromarray(filepath)
output_size = 256
transform_size = 256
enable_padding = True
# Shrink.
shrink = int(np.floor(qsize / output_size * 0.5))
if shrink > 1:
rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))
img = img.resize(rsize, PIL.Image.ANTIALIAS)
quad /= shrink
qsize /= shrink
# Crop.
border = max(int(np.rint(qsize * 0.1)), 3)
crop = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))),
int(np.ceil(max(quad[:, 1]))))
crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]),
min(crop[3] + border, img.size[1]))
if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:
img = img.crop(crop)
quad -= crop[0:2]
# Pad.
pad = (int(np.floor(min(quad[:, 0]))), int(np.floor(min(quad[:, 1]))), int(np.ceil(max(quad[:, 0]))),
int(np.ceil(max(quad[:, 1]))))
pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0),
max(pad[3] - img.size[1] + border, 0))
if enable_padding and max(pad) > border - 4:
pad = np.maximum(pad, int(np.rint(qsize * 0.3)))
img = np.pad(np.float32(img), ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')
h, w, _ = img.shape
y, x, _ = np.ogrid[:h, :w, :1]
mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w - 1 - x) / pad[2]),
1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h - 1 - y) / pad[3]))
blur = qsize * 0.02
img += (scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)
img += (np.median(img, axis=(0, 1)) - img) * np.clip(mask, 0.0, 1.0)
img = PIL.Image.fromarray(np.uint8(np.clip(np.rint(img), 0, 255)), 'RGB')
quad += pad[:2]
# Transform.
img = img.transform((transform_size, transform_size), PIL.Image.QUAD, (quad + 0.5).flatten(), PIL.Image.BILINEAR)
if output_size < transform_size:
img = img.resize((output_size, output_size), PIL.Image.ANTIALIAS)
return img
def chunks(lst, n):
"""Yield successive n-sized chunks from lst."""
for i in range(0, len(lst), n):
yield lst[i:i + n]
def extract_on_paths(file_paths, face_detector):
pid = mp.current_process().name
print('\t{} is starting to extract on #{} images'.format(pid, len(file_paths)))
tot_count = len(file_paths)
count = 0
for file_path, res_path in file_paths:
count += 1
if count % 100 == 0:
print('{} done with {}/{}'.format(pid, count, tot_count))
try:
res = align_face(file_path, face_detector)
res = res.convert('RGB')
os.makedirs(os.path.dirname(res_path), exist_ok=True)
res.save(res_path)
except Exception:
continue
print('\tDone!')
def parse_args():
parser = ArgumentParser(add_help=False)
parser.add_argument('--num_threads', type=int, default=1)
parser.add_argument('--root_path', type=str, default='')
args = parser.parse_args()
return args
def run(args):
root_path = args.root_path
out_crops_path = root_path + '_crops'
if not os.path.exists(out_crops_path):
os.makedirs(out_crops_path, exist_ok=True)
file_paths = []
for root, dirs, files in os.walk(root_path):
for file in files:
file_path = os.path.join(root, file)
fname = os.path.join(out_crops_path, os.path.relpath(file_path, root_path))
res_path = '{}.jpg'.format(os.path.splitext(fname)[0])
if os.path.splitext(file_path)[1] == '.txt' or os.path.exists(res_path):
continue
file_paths.append((file_path, res_path))
file_chunks = list(chunks(file_paths, int(math.ceil(len(file_paths) / args.num_threads))))
print(len(file_chunks))
pool = mp.Pool(args.num_threads)
print('Running on {} paths\nHere we goooo'.format(len(file_paths)))
tic = time.time()
pool.starmap(extract_on_paths, [(chunk, face_detector) for chunk in file_chunks])
toc = time.time()
print('Mischief managed in {}s'.format(toc - tic))
if __name__ == '__main__':
# Initialize InsightFace
face_detector = insightface.app.FaceAnalysis()
face_detector.prepare(ctx_id=-1, det_size=(640, 640)) # ctx_id=-1 for CPU
args = parse_args()
run(args)
|