|
"""This script contains basic utilities for Deep3DFaceRecon_pytorch |
|
""" |
|
from __future__ import print_function |
|
import numpy as np |
|
import torch |
|
from PIL import Image |
|
import os |
|
import importlib |
|
import argparse |
|
from argparse import Namespace |
|
import torchvision |
|
|
|
|
|
def str2bool(v): |
|
if isinstance(v, bool): |
|
return v |
|
if v.lower() in ('yes', 'true', 't', 'y', '1'): |
|
return True |
|
elif v.lower() in ('no', 'false', 'f', 'n', '0'): |
|
return False |
|
else: |
|
raise argparse.ArgumentTypeError('Boolean value expected.') |
|
|
|
|
|
def copyconf(default_opt, **kwargs): |
|
conf = Namespace(**vars(default_opt)) |
|
for key in kwargs: |
|
setattr(conf, key, kwargs[key]) |
|
return conf |
|
|
|
def genvalconf(train_opt, **kwargs): |
|
conf = Namespace(**vars(train_opt)) |
|
attr_dict = train_opt.__dict__ |
|
for key, value in attr_dict.items(): |
|
if 'val' in key and key.split('_')[0] in attr_dict: |
|
setattr(conf, key.split('_')[0], value) |
|
|
|
for key in kwargs: |
|
setattr(conf, key, kwargs[key]) |
|
|
|
return conf |
|
|
|
def find_class_in_module(target_cls_name, module): |
|
target_cls_name = target_cls_name.replace('_', '').lower() |
|
clslib = importlib.import_module(module) |
|
cls = None |
|
for name, clsobj in clslib.__dict__.items(): |
|
if name.lower() == target_cls_name: |
|
cls = clsobj |
|
|
|
assert cls is not None, "In %s, there should be a class whose name matches %s in lowercase without underscore(_)" % (module, target_cls_name) |
|
|
|
return cls |
|
|
|
|
|
def tensor2im(input_image, imtype=np.uint8): |
|
""""Converts a Tensor array into a numpy image array. |
|
|
|
Parameters: |
|
input_image (tensor) -- the input image tensor array, range(0, 1) |
|
imtype (type) -- the desired type of the converted numpy array |
|
""" |
|
if not isinstance(input_image, np.ndarray): |
|
if isinstance(input_image, torch.Tensor): |
|
image_tensor = input_image.data |
|
else: |
|
return input_image |
|
image_numpy = image_tensor.clamp(0.0, 1.0).cpu().float().numpy() |
|
if image_numpy.shape[0] == 1: |
|
image_numpy = np.tile(image_numpy, (3, 1, 1)) |
|
image_numpy = np.transpose(image_numpy, (1, 2, 0)) * 255.0 |
|
else: |
|
image_numpy = input_image |
|
return image_numpy.astype(imtype) |
|
|
|
|
|
def diagnose_network(net, name='network'): |
|
"""Calculate and print the mean of average absolute(gradients) |
|
|
|
Parameters: |
|
net (torch network) -- Torch network |
|
name (str) -- the name of the network |
|
""" |
|
mean = 0.0 |
|
count = 0 |
|
for param in net.parameters(): |
|
if param.grad is not None: |
|
mean += torch.mean(torch.abs(param.grad.data)) |
|
count += 1 |
|
if count > 0: |
|
mean = mean / count |
|
print(name) |
|
print(mean) |
|
|
|
|
|
def save_image(image_numpy, image_path, aspect_ratio=1.0): |
|
"""Save a numpy image to the disk |
|
|
|
Parameters: |
|
image_numpy (numpy array) -- input numpy array |
|
image_path (str) -- the path of the image |
|
""" |
|
|
|
image_pil = Image.fromarray(image_numpy) |
|
h, w, _ = image_numpy.shape |
|
|
|
if aspect_ratio is None: |
|
pass |
|
elif aspect_ratio > 1.0: |
|
image_pil = image_pil.resize((h, int(w * aspect_ratio)), Image.LANCZOS) |
|
elif aspect_ratio < 1.0: |
|
image_pil = image_pil.resize((int(h / aspect_ratio), w), Image.LANCZOS) |
|
image_pil.save(image_path) |
|
|
|
|
|
def print_numpy(x, val=True, shp=False): |
|
"""Print the mean, min, max, median, std, and size of a numpy array |
|
|
|
Parameters: |
|
val (bool) -- if print the values of the numpy array |
|
shp (bool) -- if print the shape of the numpy array |
|
""" |
|
x = x.astype(np.float64) |
|
if shp: |
|
print('shape,', x.shape) |
|
if val: |
|
x = x.flatten() |
|
print('mean = %3.3f, min = %3.3f, max = %3.3f, median = %3.3f, std=%3.3f' % ( |
|
np.mean(x), np.min(x), np.max(x), np.median(x), np.std(x))) |
|
|
|
|
|
def mkdirs(paths): |
|
"""create empty directories if they don't exist |
|
|
|
Parameters: |
|
paths (str list) -- a list of directory paths |
|
""" |
|
if isinstance(paths, list) and not isinstance(paths, str): |
|
for path in paths: |
|
mkdir(path) |
|
else: |
|
mkdir(paths) |
|
|
|
|
|
def mkdir(path): |
|
"""create a single empty directory if it didn't exist |
|
|
|
Parameters: |
|
path (str) -- a single directory path |
|
""" |
|
if not os.path.exists(path): |
|
os.makedirs(path) |
|
|
|
|
|
def correct_resize_label(t, size): |
|
device = t.device |
|
t = t.detach().cpu() |
|
resized = [] |
|
for i in range(t.size(0)): |
|
one_t = t[i, :1] |
|
one_np = np.transpose(one_t.numpy().astype(np.uint8), (1, 2, 0)) |
|
one_np = one_np[:, :, 0] |
|
one_image = Image.fromarray(one_np).resize(size, Image.NEAREST) |
|
resized_t = torch.from_numpy(np.array(one_image)).long() |
|
resized.append(resized_t) |
|
return torch.stack(resized, dim=0).to(device) |
|
|
|
|
|
def correct_resize(t, size, mode=Image.LANCZOS): |
|
device = t.device |
|
t = t.detach().cpu() |
|
resized = [] |
|
for i in range(t.size(0)): |
|
one_t = t[i:i + 1] |
|
one_image = Image.fromarray(tensor2im(one_t)).resize(size, Image.LANCZOS) |
|
resized_t = torchvision.transforms.functional.to_tensor(one_image) * 2 - 1.0 |
|
resized.append(resized_t) |
|
return torch.stack(resized, dim=0).to(device) |
|
|
|
def draw_landmarks(img, landmark, color='r', step=2): |
|
""" |
|
Return: |
|
img -- numpy.array, (B, H, W, 3) img with landmark, RGB order, range (0, 255) |
|
|
|
|
|
Parameters: |
|
img -- numpy.array, (B, H, W, 3), RGB order, range (0, 255) |
|
landmark -- numpy.array, (B, 68, 2), y direction is opposite to v direction |
|
color -- str, 'r' or 'b' (red or blue) |
|
""" |
|
if color =='r': |
|
c = np.array([255., 0, 0]) |
|
else: |
|
c = np.array([0, 0, 255.]) |
|
|
|
_, H, W, _ = img.shape |
|
img, landmark = img.copy(), landmark.copy() |
|
landmark[..., 1] = H - 1 - landmark[..., 1] |
|
landmark = np.round(landmark).astype(np.int32) |
|
for i in range(landmark.shape[1]): |
|
x, y = landmark[:, i, 0], landmark[:, i, 1] |
|
for j in range(-step, step): |
|
for k in range(-step, step): |
|
u = np.clip(x + j, 0, W - 1) |
|
v = np.clip(y + k, 0, H - 1) |
|
for m in range(landmark.shape[0]): |
|
img[m, v[m], u[m]] = c |
|
return img |
|
|
