|
import os |
|
|
|
|
|
from models.psp import pSp |
|
import torch |
|
import dlib |
|
import cv2 |
|
import PIL |
|
import argparse |
|
from tqdm import tqdm |
|
import numpy as np |
|
import torch.nn.functional as F |
|
import torchvision |
|
from torchvision import transforms, utils |
|
from argparse import Namespace |
|
from datasets import augmentations |
|
from scripts.align_all_parallel import align_face |
|
from latent_optimization import latent_optimization |
|
from utils.inference_utils import save_image, load_image, visualize, get_video_crop_parameter, tensor2cv2, tensor2label, labelcolormap |
|
|
|
class TestOptions(): |
|
def __init__(self): |
|
|
|
self.parser = argparse.ArgumentParser(description="StyleGANEX Video Editing") |
|
self.parser.add_argument("--data_path", type=str, default='./data/390.mp4', help="path of the target image/video") |
|
self.parser.add_argument("--ckpt", type=str, default='pretrained_models/styleganex_toonify_cartoon.pt', help="path of the saved model") |
|
self.parser.add_argument("--output_path", type=str, default='./output/', help="path of the output results") |
|
self.parser.add_argument("--scale_factor", type=float, default=1.0, help="scale of the editing degree") |
|
self.parser.add_argument("--cpu", action="store_true", help="if true, only use cpu") |
|
|
|
def parse(self): |
|
self.opt = self.parser.parse_args() |
|
args = vars(self.opt) |
|
print('Load options') |
|
for name, value in sorted(args.items()): |
|
print('%s: %s' % (str(name), str(value))) |
|
return self.opt |
|
|
|
|
|
if __name__ == "__main__": |
|
parser = TestOptions() |
|
args = parser.parse() |
|
print('*'*98) |
|
|
|
device = "cpu" if args.cpu else "cuda" |
|
|
|
transform = transforms.Compose([ |
|
transforms.ToTensor(), |
|
transforms.Normalize(mean=[0.5, 0.5, 0.5],std=[0.5,0.5,0.5]), |
|
]) |
|
|
|
ckpt = torch.load(args.ckpt, map_location='cpu') |
|
opts = ckpt['opts'] |
|
opts['checkpoint_path'] = args.ckpt |
|
opts['device'] = device |
|
opts = Namespace(**opts) |
|
pspex = pSp(opts).to(device).eval() |
|
pspex.latent_avg = pspex.latent_avg.to(device) |
|
editing_w = None |
|
if 'editing_w' in ckpt.keys(): |
|
editing_w = ckpt['editing_w'].clone().to(device)[0:1] * args.scale_factor |
|
|
|
modelname = 'pretrained_models/shape_predictor_68_face_landmarks.dat' |
|
if not os.path.exists(modelname): |
|
import wget, bz2 |
|
wget.download('http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2', modelname+'.bz2') |
|
zipfile = bz2.BZ2File(modelname+'.bz2') |
|
data = zipfile.read() |
|
open(modelname, 'wb').write(data) |
|
landmarkpredictor = dlib.shape_predictor(modelname) |
|
|
|
print('Load models successfully!') |
|
|
|
video_path = args.data_path |
|
video_cap = cv2.VideoCapture(video_path) |
|
success, frame = video_cap.read() |
|
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) |
|
|
|
paras = get_video_crop_parameter(frame, landmarkpredictor) |
|
assert paras is not None, 'StyleGANEX uses dlib.get_frontal_face_detector but sometimes it fails to detect a face. \ |
|
You can try several times or use other videos until a face is detected, \ |
|
then switch back to the original video.' |
|
h,w,top,bottom,left,right,scale = paras |
|
H, W = int(bottom-top), int(right-left) |
|
frame = cv2.resize(frame, (w, h))[top:bottom, left:right] |
|
|
|
x1 = transform(frame).unsqueeze(0).to(device) |
|
with torch.no_grad(): |
|
x2 = align_face(frame, landmarkpredictor) |
|
x2 = transform(x2).unsqueeze(dim=0).to(device) |
|
|
|
save_name = '%s/%s_%s'%(args.output_path, os.path.basename(video_path).split('.')[0], os.path.basename(args.ckpt).split('.')[0]) |
|
|
|
num = int(video_cap.get(7)) |
|
|
|
if num == 1: |
|
save_name = save_name + '.jpg' |
|
else: |
|
save_name = save_name + '.mp4' |
|
fourcc = cv2.VideoWriter_fourcc(*'mp4v') |
|
videoWriter = cv2.VideoWriter(save_name, fourcc, video_cap.get(5), (4*W, 4*H)) |
|
|
|
with torch.no_grad(): |
|
for i in tqdm(range(num)): |
|
if i > 0: |
|
success, frame = video_cap.read() |
|
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) |
|
frame = cv2.resize(frame, (w, h))[top:bottom, left:right] |
|
|
|
x1 = transform(frame).unsqueeze(0).to(device) |
|
y_hat = pspex(x1=x1, x2=x2, use_skip=pspex.opts.use_skip, zero_noise=True, |
|
resize=False, editing_w=editing_w) |
|
y_hat = torch.clamp(y_hat, -1, 1) |
|
|
|
if num > 1: |
|
videoWriter.write(tensor2cv2(y_hat[0].cpu())) |
|
|
|
if num == 1: |
|
save_image(y_hat[0].cpu(), save_name) |
|
print('Image editing successfully!') |
|
else: |
|
videoWriter.release() |
|
print('Video editing successfully!') |
|
|
|
|
