|
|
|
|
|
|
|
|
|
|
|
from __future__ import print_function |
|
|
|
|
|
import os |
|
|
|
|
|
import PIL |
|
|
import numpy as np |
|
|
import torch |
|
|
import torch.nn.functional as F |
|
|
from PIL import Image |
|
|
from torchvision.utils import make_grid |
|
|
|
|
|
|
|
|
def array2image(ndarray): |
|
|
return PIL.Image.fromarray(np.uint8(ndarray)).convert('RGB') |
|
|
|
|
|
|
|
|
def tensor_to_ndarray(tensor, nrow=1, padding=0, normalize=True): |
|
|
grid = make_grid(tensor, nrow, padding, normalize) |
|
|
return grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to("cpu", torch.uint8).numpy() |
|
|
|
|
|
|
|
|
def irregular_hole_synthesize(image, mask): |
|
|
img_np = np.array(image).astype("uint8") |
|
|
mask_np = np.array(mask).astype("uint8") |
|
|
mask_np = mask_np / 255 |
|
|
img_new = img_np * (1 - mask_np) + mask_np * 255 |
|
|
return PIL.Image.fromarray(img_new.astype("uint8")).convert("RGB") |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def tensor2im(image_tensor, imtype=np.uint8, normalize=True): |
|
|
if isinstance(image_tensor, list): |
|
|
image_numpy = [] |
|
|
for i in range(len(image_tensor)): |
|
|
image_numpy.append(tensor2im(image_tensor[i], imtype, normalize)) |
|
|
return image_numpy |
|
|
image_numpy = image_tensor.cpu().float().numpy() |
|
|
if normalize: |
|
|
image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + 1) / 2.0 * 255.0 |
|
|
else: |
|
|
image_numpy = np.transpose(image_numpy, (1, 2, 0)) * 255.0 |
|
|
image_numpy = np.clip(image_numpy, 0, 255) |
|
|
if image_numpy.shape[2] == 1 or image_numpy.shape[2] > 3: |
|
|
image_numpy = image_numpy[:, :, 0] |
|
|
return image_numpy.astype(imtype) |
|
|
|
|
|
|
|
|
|
|
|
def tensor2label(label_tensor, n_label, imtype=np.uint8): |
|
|
if n_label == 0: |
|
|
return tensor2im(label_tensor, imtype) |
|
|
label_tensor = label_tensor.cpu().float() |
|
|
if label_tensor.size()[0] > 1: |
|
|
label_tensor = label_tensor.max(0, keepdim=True)[1] |
|
|
label_tensor = Colorize(n_label)(label_tensor) |
|
|
label_numpy = np.transpose(label_tensor.numpy(), (1, 2, 0)) |
|
|
return label_numpy.astype(imtype) |
|
|
|
|
|
|
|
|
def scale_tensor(img_tensor, default_scale=256): |
|
|
_, _, w, h = img_tensor.shape |
|
|
if w < h: |
|
|
ow = default_scale |
|
|
oh = h / w * default_scale |
|
|
else: |
|
|
oh = default_scale |
|
|
ow = w / h * default_scale |
|
|
|
|
|
oh = int(round(oh / 16) * 16) |
|
|
ow = int(round(ow / 16) * 16) |
|
|
|
|
|
return F.interpolate(img_tensor, [ow, oh], mode="bilinear") |
|
|
|
|
|
|
|
|
def data_transforms(img, size="full_size", method=Image.BICUBIC): |
|
|
if size == "full_size": |
|
|
ow, oh = img.size |
|
|
h = int(round(oh / 16) * 16) |
|
|
w = int(round(ow / 16) * 16) |
|
|
if (h == oh) and (w == ow): |
|
|
return img |
|
|
return img.resize((w, h), method) |
|
|
|
|
|
elif size == "scale_256": |
|
|
ow, oh = img.size |
|
|
pw, ph = ow, oh |
|
|
if ow < oh: |
|
|
ow = 256 |
|
|
oh = ph / pw * 256 |
|
|
else: |
|
|
oh = 256 |
|
|
ow = pw / ph * 256 |
|
|
|
|
|
h = int(round(oh / 16) * 16) |
|
|
w = int(round(ow / 16) * 16) |
|
|
if (h == ph) and (w == pw): |
|
|
return img |
|
|
return img.resize((w, h), method) |
|
|
|
|
|
|
|
|
def save_image(image_numpy, image_path): |
|
|
image_pil = Image.fromarray(image_numpy) |
|
|
image_pil.save(image_path) |
|
|
|
|
|
|
|
|
def mkdirs(paths): |
|
|
if isinstance(paths, list) and not isinstance(paths, str): |
|
|
for path in paths: |
|
|
mkdir(path) |
|
|
else: |
|
|
mkdir(paths) |
|
|
|
|
|
|
|
|
def mkdir(path): |
|
|
if not os.path.exists(path): |
|
|
os.makedirs(path) |
|
|
|
