def render(self, file_name='animation.mov'):
sizes = numpy.arange(8, self.opt.vmax_size + 1, 8)
save_dir = os.path.join(self.opt.results_dir, self.opt.name)
for size in sizes:
name = os.path.join(save_dir, 'v{:03d}.npy'.format(size))
if os.path.exists(name):
v = np.load(name)
name = os.path.join(save_dir, 'w{:03d}.npy'.format(size))
if os.path.exists(name):
w = np.load(name)
if v is None or w is None:
print('vXXX.npy or wXXX.npy does not exist.')
return
else:
img0_src = cv2.imread(self.opt.datarootA)
img1_src = cv2.imread(self.opt.datarootB)
v_final = resize_v(v=v, size=img0_src.shape[0])
w_final = resize_v(v=w, size=img0_src.shape[0])
# v_final = resize_v(v=v, size=img0_src.shape[1], size_x=img0_src.shape[0])
# w_final = resize_v(v=w, size=img0_src.shape[1], size_x=img0_src.shape[0])
img1 = cv2.resize(img1_src, (img0_src.shape[0], img0_src.shape[0]))
save_path = os.path.join(save_dir, file_name)
render_animation(img0_src, img1, v_final, w=w_final,
steps=self.opt.render_steps, time=self.opt.render_time,
file_name=save_path)
return
def test_render(self):
img0 = cv2.imread('tests/data/nbb/original_A.png')
img1 = cv2.imread('tests/data/nbb/original_B.png')
v = np.load('tests/data/nbb/AtoB.npy')
render_animation(img0, img1, v,
file_name='tests/data/render/animation.mov',
steps=30)
return
def image_morphing(img0_path, img1_path, p0_path, p1_path, vmax_size=32, render_name='animation.mov',
lr_v=7e-2, tol_v=1e-1, lr_w=7e-2, tol_w=1e-3, lambda_tps=1e-3, gamma_ui=1e2,
tol_count_v=20, tol_count_w=3, render=False, render_steps=60, render_time=1,
save_dir='.cache'):
img0_src = cv2.imread(img0_path)
img1_src = cv2.imread(img1_path)
p0_src = load_points(p0_path)
p1_src = load_points(p1_path)
size = 8
v = np.random.randn(size, size, 2)
w = np.random.randn(size, size, 2)
# sizes = np.arange(8, vmax_size + 1, 8)
sizes = 2 ** np.arange(3, 10)
sizes = sizes[sizes <= vmax_size]
if GPU:
sizes = np.asnumpy(sizes)
for size in sizes:
print('\nOptimization size {:3d} start.'.format(size))
name = os.path.join(save_dir, 'v{:03d}'.format(size))
if os.path.exists(name):
v = np.load(name)
else:
print('Optimization of v start.')
v = adam(size, img0_src, img1_src, v, p0_src, p1_src, lr=lr_v, tol=tol_v,
render=render, tol_count=tol_count_v, lambda_tps=lambda_tps,
gamma_ui=gamma_ui, save_dir=save_dir)
name = os.path.join(save_dir, 'w{:03d}'.format(size))
if os.path.exists(name):
w = np.load(w)
else:
print('Optimization of w start.')
w = adam_w(size, w, v, lr=lr_w, tol=tol_w, tol_count=tol_count_w,
save_dir=save_dir)
v_final = resize_v(v=v, size=img0_src.shape[0], size_x=img0_src.shape[1])
w_final = resize_v(v=w, size=img0_src.shape[0], size_x=img0_src.shape[1])
img1 = cv2.resize(img1_src, (img0_src.shape[0], img0_src.shape[1]))
render_path = os.path.join(save_dir, render_name)
render_animation(img0_src, img1, v_final, w=w_final, steps=render_steps,
time=render_time, file_name=render_path)
def optimize_v_size(size, img0_src, img1_src, v_src, p0_src, p1_src, method=None,
tol=1e-1, lambda_tps=1e-3, gamma_ui=1e2):
global _args, _iter, _prev_time, _elapsed_time
img0, img1, v0, p0, p1 = resize_all(size, img0_src, img1_src, v_src, p0_src, p1_src)
_args = (img0, img1, p0, p1, lambda_tps, gamma_ui)
_iter = 0
_prev_time = start = time.time()
_elapsed_time = 0
res = minimize(E, v0, args=_args, method=method, callback=log_cb, tol=tol)
end = time.time()
print('Time: {:.3f}'.format(end - start))
print(res.message)
v_opt = res.x
v_opt = v_opt.reshape(v0.shape)
name = '.cache/v{:03d}_{}'.format(size, datetime.now().strftime('%m%d%H%M'))
# render_animation(img0, img1, v_opt, file_name=name+'.mov')
img0_256, img1_256, v256, _, _ = resize_all(256, img0_src, img1_src, v_opt, p0_src, p1_src)
render_animation(img0_256, img1_256, v256, file_name=name+'.mov')
half = render(img0, img1, v_opt)
np.save(name + '.npy', v_opt)
return v_opt, res, half
def sgd(size, img0_src, img1_src, v_src, p0_src, p1_src, tol=1e-1, lambda_tps=1e-3, gamma_ui=1e2, lr=1e-2, return_half=False):
img0, img1, v, p0, p1 = resize_all(size, img0_src, img1_src, v_src, p0_src, p1_src)
args = (img0, img1, p0, p1, lambda_tps, gamma_ui)
iter = 0
start = prev = time.time()
log_interbal = 0
prev_e = 1e10
while 1:
dedv, e = dEdv(v, *args)
# describe(dedv)
v = v - lr * dedv
iter += 1
log_interbal += time.time() - prev
prev = time.time()
if log_interbal > _LOGINTERBAL:
if GPU:
ev = np.asnumpy(E(v, *args))
else:
ev = E(v, *args)
print('iter {:4d}, E: {:.4f}, time: {:.1f} s'.format(
iter, ev, time.time() - start))
log_interbal = 0
if abs(prev_e - e) < tol:
break
prev_e = e
end = time.time()
print('Time: {:.3f}'.format(end - start))
name = '.cache/v{:03d}_{}'.format(size, datetime.now().strftime('%m%d%H%M'))
img0_256, img1_256, v256, _, _ = resize_all(256, img0_src, img1_src, v, p0_src, p1_src)
render_animation(img0_256, img1_256, v256, file_name=name+'.mov')
np.save(name + '.npy', v)
if return_half:
half = render(img0, img1, v)
return v, half
else:
return v
def adam(size, img0_src, img1_src, v_src, p0_src, p1_src, tol=1e-1, tol_count=20,
lambda_tps=1e-3, gamma_ui=1e2, lr=1e-4, beta1=0.9, beta2=0.999, eps=1e-8,
render=True, save_dir='.cache'):
img0, img1, v, p0, p1 = resize_all(size, img0_src, img1_src, v_src, p0_src, p1_src)
args = (img0, img1, p0, p1, lambda_tps, gamma_ui)
iter = 0
start = prev = time.time()
log_interbal = 0
prev_e = 1e10
count = 0
m = np.zeros_like(v)
vt = np.zeros_like(v)
try:
while 1:
grads, e = dEdv(v, *args)
iter += 1
lr_t = lr * np.sqrt(1.0 - beta2**iter) / (1.0 - beta1**iter)
m += (1 - beta1) * (grads - m)
vt += (1 - beta2) * (grads**2 - vt)
v -= lr_t * m / (np.sqrt(vt) + 1e-7)
#unbias_m += (1 - beta1) * (grads - m) # correct bias
#unbisa_b += (1 - beta2) * (grads*grads - vt) # correct bias
#params += lr * unbias_m / (np.sqrt(unbisa_b) + 1e-7)
log_interbal += time.time() - prev
prev = time.time()
if log_interbal > _LOGINTERBAL or iter == 1:
if GPU:
ev = np.asnumpy(E(v, *args))
else:
ev = E(v, *args)
print('iter {:4d}, E: {:.4f}, time: {:.1f} s'.format(
iter, ev, time.time() - start))
log_interbal = 0
if abs(prev_e - e) < tol and e < prev_e:
break
elif prev_e < e:
count += 1
if count >= tol_count:
break
prev_e = e
except KeyboardInterrupt:
print('Interrupted')
name = os.path.join(save_dir, 'v{:03d}'.format(size))
img0_256, img1_256, v256, _, _ = resize_all(256, img0_src, img1_src, v, p0_src, p1_src)
if render:
render_animation(img0_256, img1_256, v256, file_name=name+'.mov')
np.save(name + '.npy', v)
return v
end = time.time()
if GPU:
ev = np.asnumpy(E(v, *args))
else:
ev = E(v, *args)
print('iter {:4d}, E: {:.4f}, time: {:.1f} s'.format(
iter, ev, end - start))
print('Optimization of v finished!')
name = os.path.join(save_dir, 'v{:03d}'.format(size))
img0_256, img1_256, v256, _, _ = resize_all(256, img0_src, img1_src, v, p0_src, p1_src)
if render:
render_animation(img0_256, img1_256, v256, file_name=name+'.mov')
np.save(name + '.npy', v)
return v