def run(self, opt):
if opt.crop_image:
source_image = image_crop(opt.source_image, opt.crop_image_padding)
else:
source_image = imageio.imread(opt.source_image)
reader = imageio.get_reader(opt.driving_video)
source_image = resize(source_image, (256, 256))[..., :3]
fps = reader.get_meta_data()['fps']
driving_video = []
try:
for im in reader:
driving_video.append(im)
except RuntimeError:
pass
reader.close()
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
generator, kp_detector = load_checkpoints(
config_path=opt.config, checkpoint_path=opt.checkpoint)
if opt.find_best_frame or opt.best_frame is not None:
i = opt.best_frame if opt.best_frame is not None else find_best_frame(
source_image, driving_video, cpu=opt.cpu)
print("Best frame: " + str(i))
driving_forward = driving_video[i:]
driving_backward = driving_video[:(i + 1)][::-1]
predictions_forward = make_animation(
source_image,
driving_forward,
generator,
kp_detector,
relative=opt.relative,
adapt_movement_scale=opt.adapt_scale,
cpu=opt.cpu)
predictions_backward = make_animation(
source_image,
driving_backward,
generator,
kp_detector,
relative=opt.relative,
adapt_movement_scale=opt.adapt_scale,
cpu=opt.cpu)
predictions = predictions_backward[::-1] + predictions_forward[1:]
else:
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=opt.relative,
adapt_movement_scale=opt.adapt_scale,
cpu=opt.cpu)
#predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=True)
imageio.mimsave(opt.output,
[img_as_ubyte(frame) for frame in predictions],
fps=fps)
def first_order(user_id: int):
data = prepare_data(user_id)
if data['photo']:
predictions = make_photo_animation(
data['source_media'], data['target_media'],
data['generator'], data['kp_detector'],
relative=RELATIVE,
adapt_movement_scale=ADAPT_SCALE,
cpu=CPU
)
else:
predictions = make_animation(
data['source_media'], data['target_media'],
data['generator'], data['kp_detector'],
relative=RELATIVE,
adapt_movement_scale=ADAPT_SCALE,
cpu=CPU
)
# imageio.mimsave(f'{PATH}1.mp4', [img_as_ubyte(frame) for frame in predictions], "mp4", fps=data['fps'])
filename = f'{PATH}{user_id}'
imageio.mimsave(filename + '.mp4',
[super_resolution(img_as_ubyte(frame), 4) for frame in predictions],
"mp4", fps=data['fps'])
video_clip = VideoFileClip(filename + '.mp4')
video_clip.audio = data['audio']
try:
video_clip.write_videofile(filename + '_a' + '.mp4')
except Exception as e:
print(e)
video_clip = VideoFileClip(filename + '.mp4')
video_clip.write_videofile(filename + '_a' + '.mp4')
def generate_raw_output(self):
source, vid, start_time = self.source, self.vid, self.start_time
photoname = self.processed_image.split('.')[0] + '.png'
source_image = imageio.imread(
f'aligned_images/{start_time}/{photoname}')
source_image = resize(source_image, (256, 256))[..., :3]
placeholder_bytes = base64.b64decode(
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII='
)
placeholder_image = imageio.imread(placeholder_bytes, '.png')
placeholder_image = resize(placeholder_image, (256, 256))[..., :3]
ims = []
try:
driving_video = imageio.get_reader(vid)
for im in driving_video:
ims.append(im)
except Exception as e:
print('Error: ', e)
self.update_status("20")
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
predictions = make_animation(source_image,
driving_video,
ModelPipeline.generator,
ModelPipeline.kp_detector,
relative=True)
self.videoname = videoname = f'result-{start_time}.mp4'
imageio.mimsave(f'video/intermediate/{start_time}/{videoname}',
[img_as_ubyte(frame) for frame in predictions])
self.update_status("40")
return self
def get(source_image, driving_video):
source_image = imageio.imread(source_image)
driving_video = imageio.mimread(driving_video)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
generator, kp_detector = load_checkpoints(
config_path='./first-order-motion-model/config/vox-256.yaml',
checkpoint_path='./vox-cpk.pth.tar')
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
#save resulting video
imageio.mimsave('./files/generated.mp4',
[img_as_ubyte(frame) for frame in predictions])
#video can be downloaded from /content folder
return True
def get_predictions(photo, video):
t = time()
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml', checkpoint_path=checkpoint_path)
# '/content/gdrive/My Drive/DepFak/vox-adv-cpk.pth.tar'
predictions = make_animation(photo,
video,
generator,
kp_detector,
relative=True)
printer.log('PREDICTION TIME', time() - t)
return predictions
def process_image(source_image, base, current, net, generator, kp_detector,
relative):
predictions = make_animation(source_image, [base, current],
generator,
kp_detector,
relative=relative,
adapt_movement_scale=False,
cpu=False)
#print("Device",torch.cuda.current_device())
#print("Device Name:",torch.cuda.get_device_name(gpu_id))
# predictions = [1]# predictions[..., ::-1]
# predictions = (np.clip(predictions, 0, 1) * 255).astype(np.uint8)
return predictions[1]
def animate_image(source_image, driving_video, savepath, configpath,
checkpointpath):
generator, kp_detector = load_checkpoints(config_path=configpath,
checkpoint_path=checkpointpath)
"""**Perform image animation**"""
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
#save resulting video
imageio.mimsave(savepath, [img_as_ubyte(frame) for frame in predictions])
def generate():
source_image = imageio.imread(image_path)
driving_video = imageio.mimread(video_path)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [resize(frame, (256, 256))[..., :3] for frame in driving_video]
#Create a model and load checkpoints
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(config_path='config/vox-256.yaml',
checkpoint_path='first-order-motion-model/vox-cpk.pth.tar')
#Perform image animation
from demo import make_animation
from skimage import img_as_ubyte
predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=True)
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(config_path='config/vox-256.yaml',
checkpoint_path='first-order-motion-model/vox-cpk.pth.tar')
from demo import make_animation
from skimage import img_as_ubyte
predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=True)
#save resulting video
imageio.mimsave(output_path, [img_as_ubyte(frame) for frame in predictions])
print('video saved at ' + output_path)
def convert_image_to_video(uploadimage, outputPath):
print("다메다메 밈 작업중", end=' ')
warnings.filterwarnings("ignore")
source_image = imageio.imread(uploadimage)
driving_video = imageio.mimread(os.path.join(config.dame_path, '04.mp4'))
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
def display(source, driving, generated=None):
fig = plt.figure(figsize=(8 + 4 * (generated is not None), 6))
ims = []
for i in range(len(driving)):
cols = [source, driving[i]]
if generated is not None:
cols.append(generated[i])
im = plt.imshow(np.concatenate(cols, axis=1), animated=True)
plt.axis('off')
ims.append([im])
ani = animation.ArtistAnimation(fig,
ims,
interval=50,
repeat_delay=1000)
plt.close()
return ani
generator, kp_detector = load_checkpoints(
config_path=os.path.join(config.first_order_model_path,
'config/vox-256.yaml'),
checkpoint_path=os.path.join(config.dame_path, 'vox-cpk.pth.tar'))
# make video
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
imageio.mimsave(outputPath, [img_as_ubyte(frame) for frame in predictions])
print('done')
return outputPath
def deepfake_m(source_image, driving_video):
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml',
checkpoint_path=
'/content/gdrive/My Drive/first-order-motion-model/vox-cpk.pth.tar')
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
#save resulting video
imageio.mimsave('../generated.mp4',
[img_as_ubyte(frame) for frame in predictions])
#video can be downloaded from /content folder
# HTML(display(source_image, driving_video, predictions).to_html5_video())
return predictions
def animate(self, driver, target, size=(256, 256)):
"""
Uses First Order Model project to animate the target image using the
driver video.
:param driver: DGVideo object for the driver video.
:param target: DGImage object for the target image.
:param size: Tuple for dimensions to work with.
"""
# An awkward way of resizing the inputs
image = target.resize(size=size)
video = driver.get_video()
video = DGVideo.from_video(video, size=size, fps=driver.fps)
video = driver.get_video(mode='rgb', type='float')
image = image.get_image(mode='rgb', type='float')
anim = fomm_demo.make_animation(image, video,
self.generator, self.keypoint_detector,
relative=True)
return DGVideo.from_video(anim, fps=driver.fps)
def gen_dpfk(no_nvidia_gpu):
if no_nvidia_gpu:
print(
"Using CPU for further calculations... (this will be much slower)")
print("Reading template and input image...")
source_image = imageio.imread('../input_image.png')
driving_video = imageio.mimread('bakamitai_template.mp4')
#Resize image and video to 256x256
print("Resizing inputs...")
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
print("Generating video... (this may take a while)")
generator, kp_detector = demo.load_checkpoints(
config_path='first-order-model/config/vox-256.yaml',
checkpoint_path='vox-cpk.pth.tar',
cpu=no_nvidia_gpu)
predictions = demo.make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True,
cpu=no_nvidia_gpu)
print("Saving video...")
imageio.mimsave('generated.mp4',
[img_as_ubyte(frame) for frame in predictions])
def synthesize_landmark_to_face(self):
if (LandMark2FaceModel == "firstorder"):
reader = imageio.get_reader(
os.path.join("/",
*root_file_path.split("/")[:-1],
"cSpeech2Landmark/OUT/out.mp4"))
self.fps = reader.get_meta_data()['fps']
self.fps = self.fps - 5
reader.close()
source_image = imageio.imread(
os.path.join("/",
*root_file_path.split("/")[:-1],
"REF/current/ref.png"))
self.source_image = resize(source_image, (256, 256))[..., :3]
driving_video = imageio.mimread(os.path.join(
"/",
*root_file_path.split("/")[:-1],
"cSpeech2Landmark/OUT/out.mp4"),
memtest=False)
self.driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
cv2.destroyAllWindows()
predictions = make_animation(self.source_image, self.driving_video,
self.generator, self.kp_detector)
imageio.mimsave(os.path.join(root_file_path, "OUT/face.mp4"),
predictions,
fps=self.fps)
#os.chdir("../finalface")
#os.system("bash test.sh")
#os.chdir("/home/ipsum/fatssd/Anya/TTS")
#stabilize("../finalface/result.mp4","stabilized.mp4")
cmd = 'ffmpeg -y -i ' + 'dLandMark2Face/OUT/face.mp4 -i ' + 'bText2Speech/OUT/temp.wav -c:v copy -c:a aac -strict experimental fOUTPUT/queued.mp4'
os.system(cmd)
shutil.copy("fOUTPUT/queued.mp4", "Queue/queued.mp4")
def video_generator():
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml', checkpoint_path='vox-cpk.pth.tar')
print(" generator and detector loaded ... ")
source_image = 'me.png'
driving_video = '04.mp4'
source_image = imageio.imread(source_image)
reader = imageio.get_reader(driving_video)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
fps = reader.get_meta_data()['fps']
driving_video = []
try:
for im in reader:
driving_video.append(im)
except RuntimeError:
pass
reader.close()
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True,
adapt_movement_scale=True)
#save resulting video
print('generating animated video ')
imageio.mimsave('generated.mp4',
[img_as_ubyte(frame) for frame in predictions],
fps=fps)
print('video saved ...')
def generate_video(filename1):
path1 = "static/profile_pics/" + filename1 #getting path
source_image = imageio.imread(path1) #loading image
driving_video = imageio.mimread('t3.mp4') #loading template
# Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3] #resizing image
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
] #resizing template
# loading checkpoints
print("loading checkpoints")
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml', checkpoint_path='vox-cpk.pth.tar')
# performing image animation and saving video
print("importing demo and skimage")
from demo import make_animation
from skimage import img_as_ubyte
print("calling make_animation")
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
# save resulting video
# i_name , f_ext = os.path.splitext(filename1)
# videoName = "static/generated_with_api_" + i_name + "mp4"
imageio.mimsave("static/jahnavi_t4.mp4",
[img_as_ubyte(frame) for frame in predictions])
def generate_deepfake(image_path,
driver_path,
sound_path,
output_path="output/output.mp4"):
if not hasattr(DeepFakeApi, "initialized"):
DeepFakeApi.__init__()
print("Loading driver and source image")
source_image = imageio.imread(image_path)
reader = imageio.get_reader(driver_path)
meta_data = reader.get_meta_data()
fps = reader.get_meta_data()['fps']
driving_video = []
try:
for im in reader:
driving_video.append(im)
except RuntimeError:
pass
reader.close()
print("Resizing driver and source image")
source_image = resize(source_image, (256, 256))[..., :3]
# Resize only if necessary
if meta_data['source_size'] != (256, 256) and meta_data['size'] != (
256, 256):
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
else:
# We still need to remap the color values from [0,256] to [0,1]
driving_video = [(frame * (1 / 256))[..., :3]
for frame in driving_video]
print("Creating animation")
predictions = make_animation(source_image,
driving_video,
DeepFakeApi.generator,
DeepFakeApi.kp_detector,
cpu=False)
# save resulting video
print("Saving output")
clips = [
mp.ImageClip(img_as_ubyte(m)).set_duration(1 / fps)
for m in predictions
]
audio_clip = mp.AudioFileClip(sound_path)
audio_clip = audio_clip.set_end(meta_data["duration"])
concat_clip = mp.concatenate_videoclips(clips, method="compose")
concat_clip = concat_clip.set_audio(audio_clip)
# Practically infinite but not really, just in case i am a bad programmer and it doesnt end
if os.path.isfile(output_path):
path_split = output_path.split(".")
path_split.insert(-1, 1)
path_split[-1] = "." + path_split[-1]
for i in range(1, 512):
if i > 510:
print("Infinite loop error! Aborting")
break
path_split[-2] = str(i)
test_path = "".join(path_split)
if not os.path.isfile(test_path):
output_path = test_path
break
concat_clip.write_videofile(output_path, fps=fps)
for x in range(0, pieces):
print("Animating", filename, x)
# Get the snip
driving_video = imageio.mimread(os.path.join(
"input_snips", "{}_{}.mp4".format(filename.strip(".mp4"), x)),
memtest=False)
# Resize video to 256x256
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
# Perform image animation
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True,
cpu=False)
imageio.mimsave(os.path.join(
"output_snips", "{}_{}.mp4".format(filename.strip(".mp4"), x)),
[img_as_ubyte(frame) for frame in predictions],
fps=30)
# Concatenate snips
video_pieces = []
for x in range(0, pieces):
print("Merging", filename, x)
split = VideoFileClip(
os.path.join("output_snips",
"{}_{}.mp4".format(filename.strip(".mp4"), x)))
def process_image(source_image,base,current,net, generator,kp_detector,relative):
predictions = make_animation(source_image, [base,current], generator, kp_detector, relative=relative, adapt_movement_scale=False)
return predictions[1]
parser.add_argument("--video_path", type=str, default='./data/videos/04.mp4')
parser.add_argument("--use_relative",type=str2bool, nargs='?',
const=True, default=True)
#parser.add_argument("--exclude_pattern", nargs="+", default=[""])
args = parser.parse_args()
image_path = args.image_path
video_path = args.video_path
source_image = imageio.imread(image_path)
driving_video = imageio.mimread(video_path, memtest=False)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = np.array([resize(frame, (256, 256))[..., :3] for frame in driving_video])
imageio.imwrite('./generated/downscaled_image.png',source_image)
generator, kp_detector = load_checkpoints(config_path='config/vox-256.yaml',
checkpoint_path='./models/vox-cpk.pth.tar')
predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=args.use_relative)
#predictions = []
#orig_img = driving_video[0]
#for i in tqdm(range(np.shape(driving_video)[0]-1)):
# #print(np.shape(driving_video[i]))
# predictions.append(animate_image(source_image, driving_video[i],orig_img, generator, kp_detector, relative=args.use_relative))
#save resulting video
imageio.mimsave('./generated/generated.mp4', [img_as_ubyte(frame) for frame in predictions])
height = 256
source_video = movie_resize(source_video, (width, height))
x_center, y_center = width // 2, 128
source_video = movie_crop(source_video,
x_center=x_center,
y_center=y_center,
width=256,
height=256)
else:
raise NotImplementedError("Invalid Video Resize Mode")
driving_video = [(frame / 255) for frame in source_video.iter_frames()]
print()
print("Generating Video")
predictions = make_animation(source_image, driving_video, generator,
kp_detector, **options)
print()
output_clip = VideoClip(make_frame, duration=source_duration)
output_clip = output_clip.set_fps(source_fps)
output_clip = output_clip.set_audio(source_audio)
if args.image_resize == 'fill' and args.crop_output:
print(f"Cropping output video to {unfill_width}x{unfill_height}")
output_clip = movie_crop(output_clip,
x_center=256 // 2,
y_center=256 // 2,
width=unfill_width,
height=unfill_height)
print("Saving Video...")
def convert():
image_file = tk.filedialog.askopenfilename()
convert_button.destroy()
source_image = imageio.imread(image_file)
driving_video = imageio.mimread('files/04.mp4')
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
def display(source, driving, generated=None):
fig = plt.figure(figsize=(8 + 4 * (generated is not None), 6))
ims = []
for i in range(len(driving)):
cols = [source]
cols.append(driving[i])
if generated is not None:
cols.append(generated[i])
im = plt.imshow(np.concatenate(cols, axis=1), animated=True)
plt.axis('off')
ims.append([im])
ani = animation.ArtistAnimation(fig,
ims,
interval=50,
repeat_delay=1000)
plt.close()
return ani
HTML(display(source_image, driving_video).to_html5_video())
"""**Create a model and load checkpoints**"""
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml',
checkpoint_path='files/vox-cpk.pth.tar')
"""**Perform image animation**"""
from demo import make_animation
from skimage import img_as_ubyte
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
#save resulting video
imageio.mimsave('../generated.mp4',
[img_as_ubyte(frame) for frame in predictions])
#video can be downloaded from /content folder
HTML(display(source_image, driving_video, predictions).to_html5_video())
"""**In the cell above we use relative keypoint displacement to animate the objects. We can use absolute coordinates instead, but in this way all the object proporions will be inherited from the driving video. For example Putin haircut will be extended to match Trump haircut.**"""
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=False,
adapt_movement_scale=True)
HTML(display(source_image, driving_video, predictions).to_html5_video())
"""## Running on your data
**First we need to crop a face from both source image and video, while simple graphic editor like paint can be used for cropping from image. Cropping from video is more complicated. You can use ffpmeg for this.**
"""
"""**Another posibility is to use some screen recording tool, or if you need to crop many images at ones use face detector(https://github.com/1adrianb/face-alignment) , see https://github.com/AliaksandrSiarohin/video-preprocessing for preprcessing of VoxCeleb.**"""
source_image = imageio.imread('files/09.png')
driving_video = imageio.mimread('hinton.mp4', memtest=False)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True,
adapt_movement_scale=True)
HTML(display(source_image, driving_video, predictions).to_html5_video())
for i in range(len(driving)):
cols = [source]
cols.append(driving[i])
if generated is not None:
cols.append(generated[i])
im = plt.imshow(np.concatenate(cols, axis=1), animated=True)
plt.axis('off')
ims.append([im])
ani = animation.ArtistAnimation(fig, ims, interval=50, repeat_delay=1000)
plt.close()
return ani
HTML(display(source_image, driving_video).to_html5_video())
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(config_path='config/vox-256.yaml',
checkpoint_path='/content/gdrive/My Drive/first-order-motion-model/vox-cpk.pth.tar')
from demo import make_animation
from skimage import img_as_ubyte
predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=True)
#save resulting video
imageio.mimsave('../generated.mp4', [img_as_ubyte(frame) for frame in predictions])
#video can be downloaded from /content folder
HTML(display(source_image, driving_video, predictions).to_html5_video())
predictions = make_animation(source_image, driving_video, generator, kp_detector, relative=False, adapt_movement_scale=True)
HTML(display(source_image, driving_video, predictions).to_html5_video())
def run(im, vid, out):
global status_text
print(im.name, vid.name, out)
if im is None or vid is None or out == "":
print("Please complete required fields.")
return
# source_image = imageio.imread('C:/Users/Artin/first-order-model/MotionModels/armanFace3.png')
# driving_video = imageio.mimread('C:/Users/Artin/first-order-model/MotionModels/Dam.mp4')
status_text.set("Working")
#update()
try:
source_image = imageio.imread(str(im.name))
driving_video = imageio.mimread(str(vid.name))
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
# def display(source, driving, generated=None):
# fig = plt.figure(figsize=(8 + 4 * (generated is not None), 6))
#
# ims = []
# for i in range(len(driving)):
# cols = [source]
# cols.append(driving[i])
# if generated is not None:
# cols.append(generated[i])
# im = plt.imshow(np.concatenate(cols, axis=1), animated=True)
# plt.axis('off')
# ims.append([im])
#
# ani = animation.ArtistAnimation(fig, ims, interval=50, repeat_delay=1000)
# plt.close()
# return ani
# HTML(display(source_image, driving_video).to_html5_video())
"""**Create a model and load checkpoints**"""
from demo import load_checkpoints
generator, kp_detector = load_checkpoints(
config_path='config/vox-256.yaml',
checkpoint_path=
'C:/Users/Artin/first-order-model/MotionModels/vox-cpk.pth.tar')
"""**Perform image animation**"""
from demo import make_animation
from skimage import img_as_ubyte
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True)
#save resulting video
imageio.mimsave(out + '.mp4',
[img_as_ubyte(frame) for frame in predictions])
os.system("")
status_text.set(f"File saved to {os.getcwd()}{out}.mp4")
except Exception as e:
status_text.set(f"{type(e)}: {e}")
config_path='./first-order-model/config/vox-256.yaml',
checkpoint_path='./data/vox-cpk.pth.tar'
if not args.adversary else "./data/vox-adv-cpk.pth.tar",
cpu=args.cpu)
print("loading input")
source_image = imageio.imread(args.image)
driving_video = imageio.mimread('data/template.mp4', memtest=False)
source_image = resize(source_image, (256, 256))[..., :3]
driving_video = [resize(frame, (256, 256))[..., :3] for frame in driving_video]
print("making predictions")
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=args.relative,
adapt_movement_scale=args.adapt_movement_scale,
cpu=args.cpu)
RESULTS_PATH.mkdir(exist_ok=True)
output_no_audio = RESULTS_PATH.joinpath(args.image.stem + ".mp4")
output_audio = RESULTS_PATH.joinpath(args.image.stem + "_audio.mp4")
print("saving", output_no_audio)
imageio.mimsave(output_no_audio,
[img_as_ubyte(frame) for frame in predictions],
fps=30)
print("adding audio", output_audio)
cmd = f"ffmpeg -y -i {output_no_audio} -i data/template.mp3 -codec copy -shortest {output_audio}"
def GenerateVideo():
globs = globals()
disable_widget_names = [
"source_preview", "driving_preview", "generate_preview",
'source_button', 'driving_button', 'saveto_button'
]
for widget in disable_widget_names:
globs[widget].configure(state='disabled')
generate_button = globs['generate_button']
generate_button.grid_remove()
progress_var = globs['progress_var']
progress_bar = globs['progress_bar']
progress_bar.grid()
progress_label = globs['progress_label']
progress_label.grid()
source_address, driving_address, generated_address = globs[
"source_address"], globs["driving_address"], globs["generated_address"]
#Load source image and driving video
source_image = imageio.imread(source_address)
reader = imageio.get_reader(driving_address)
#Resize image and video to 256x256
source_image = resize(source_image, (256, 256))[..., :3]
fps = reader.get_meta_data()['fps']
driving_video = []
try:
for im in reader:
driving_video.append(im)
except RuntimeError:
pass
reader.close()
driving_video = [
resize(frame, (256, 256))[..., :3] for frame in driving_video
]
predictions = make_animation(source_image,
driving_video,
generator,
kp_detector,
relative=True,
adapt_movement_scale=True,
cpu=True,
progress_var=progress_var,
progress_label=progress_label)
# relative and adapt_movement_scale can be changed to obtain different results
# Save resulting video
imageio.mimsave(generated_address,
[img_as_ubyte(frame) for frame in predictions],
fps=fps)
# View generated video
message = messagebox.askquestion(title="Generation successfull.",
message="Video at:\n" +
generated_address +
"\n\nView generated video?",
icon="question")
if 'yes' in message:
os.startfile(generated_address)
globs = globals()
for widget in disable_widget_names:
globs[widget].configure(state='normal')
generate_button.grid()
progress_var.set(0)
progress_bar.grid_remove()
progress_label.grid_remove()
face_detector, previous_crop,
source_width / source_height)
frames_left -= 1
if frame is None:
# This is the case where we don't see a face at the start of a video. We just skip those frames.
frames_skipped += 1
continue
# Debug only:
# cropped_input_writer.append_data(frame)
frames.append(frame)
if len(frames) > 0:
video_empty = False
animated_image = make_animation(source_image,
frames,
generator,
kp_detector,
relative=True)
for animated_frame in animated_image:
resized_frame = img_as_ubyte(
resize(animated_frame,
(source_height, source_width))[..., :3])
original_image = np.copy(uncropped_image)
original_image[TRUMP_IMAGE_CROP[1]:TRUMP_IMAGE_CROP[1] +
TRUMP_IMAGE_CROP[3],
TRUMP_IMAGE_CROP[0]:TRUMP_IMAGE_CROP[0] +
TRUMP_IMAGE_CROP[2], :] = resized_frame
video_writer.append_data(original_image)
print(f"Num frames skipped: {frames_skipped}")
