def finalize(self):
for image_name, clean, image in zip(self.images_names,
self.best_result.cleans,
self.images):
save_image(image_name + "_watermark", self.best_result.watermark)
save_image(image_name + "_mask", self.best_result.mask)
save_image(image_name + "_obtained_mask",
self.best_result.mask * self.best_result.watermark)
save_image(image_name + "_clean", clean)
save_image(image_name + "_original", image)
def segment_all(one_obj_path, output_path):
for image in glob.glob(one_obj_path + "input/*"):
name = image[len(one_obj_path + "input/"):-4]
print("processing {}".format(name))
#fg = image.replace("input/", "output_fg/").replace(".jpg", ".png")
#bg = image.replace("input/", "output_bg/").replace(".jpg", ".png")
masks = []
im = prepare_image(image)
#fg = prepare_image(fg)
#bg = prepare_image(bg)
fg = None
bg = None
for i in range(5):
s = Segmentation("1obj_{}".format(i) + name,
im,
bg_hint=bg,
fg_hint=fg,
plot_during_training=True,
output_path=output_path)
s.optimize()
masks.append(s.best_result.mask)
save_image("1obj_" + name + "_final_mask", median(masks), output_path)
def watermarks2_example_no_hint():
# im1 = prepare_image('data/watermark/123RF_1.jpg')
# im2 = prepare_image('data/watermark/123RF_2.jpg')
# im3 = prepare_image('data/watermark/123RF_3.jpg')
# im4 = prepare_image('data/watermark/123RF_4.jpg')
# results = []
# for i in range(7):
# # TODO: make it median
# s = ManyImagesWatermarkNoHint(["123rf_example_{}".format(i) for i in range(4)], [im1, im2, im3, im4])
# s.optimize()
# s.finalize()
im1 = prepare_image('data/watermark/fotolia1.jpg')
im2 = prepare_image('data/watermark/fotolia2.jpg')
im3 = prepare_image('data/watermark/fotolia3.jpg')
results = []
for i in range(5):
# TODO: make it median
s = ManyImagesWatermarkNoHint(
["fotolia_example_{}".format(i) for i in range(3)],
[im1, im2, im3])
s.optimize()
results.append(s.best_result)
# namedtuple("ManyImageWatermarkResult", ['cleans', 'mask', 'watermark', 'psnr'])
obtained_watermark = median(
[result.mask * result.watermark for result in results])
obtained_im1 = median([result.cleans[0] for result in results])
obtained_im2 = median([result.cleans[1] for result in results])
obtained_im3 = median([result.cleans[2] for result in results])
# obtained_mask = median([result.mask for result in results])
v = np.zeros_like(obtained_watermark)
v[obtained_watermark < 0.03] = 1
final_im1 = v * im1 + (1 - v) * obtained_im1
final_im2 = v * im2 + (1 - v) * obtained_im2
final_im3 = v * im3 + (1 - v) * obtained_im3
save_image("fotolia1_final", final_im1)
save_image("fotolia2_final", final_im2)
save_image("fotolia3_final", final_im3)
save_image("fotolia_final_watermark", obtained_watermark)
def ambiguity_experiment_example():
im1 = prepare_image('data/experiments/texture3.jpg')
im2 = prepare_image('data/experiments/texture1.jpg')
im3 = prepare_image('data/experiments/texture4.jpg')
im4 = prepare_image('data/experiments/texture6.jpg')
im1_new = im1
im1_new[:, :, :im1.shape[2] // 2] = im4[:, :, :im1.shape[2] // 2]
im2_new = im2
# im4 = np_imresize(im4, output_shape=im2.shape)
im2_new[:, :, :im2.shape[2] // 2] = im3[:, :, :im2.shape[2] // 2]
save_image("input1", im1_new)
save_image("input2", im2_new)
mixed = (im1_new + im2_new) / 2
save_image("mixed", mixed)
exit()
for i in range(10):
# mixed = prepare_gray_image('data/experiments/97033.jpg')
# mixed = prepare_gray_image('data/separation/c.jpg')
s = Separation("mixed_{}".format(i), mixed, num_iter=8000)
s.optimize()
s.finalize()
def finalize(self):
self.net_output1 = self.net1(self.net_input1)
self.net_output2 = self.net2(self.net_input2)
save_image("original_image1", self.image1)
save_image("original_image2", self.image2)
save_image("learn_on", self.first_half)
save_image("apply_on", self.second_half)
save_image("learned_image1", torch_to_np(self.net_output1))
save_image("learned_image2", torch_to_np(self.net_output2))
def finalize(self):
save_image(self.image_name + "_watermark", self.best_result.watermark)
save_image(self.image_name + "_clean1", self.best_result.clean1)
save_image(self.image_name + "_clean2", self.best_result.clean2)
save_image(self.image_name + "_original1", self.image1)
save_image(self.image_name + "_original2", self.image2)
save_image(
self.image_name + "_final1",
self.image1 - self.best_result.watermark * self.watermark_hint)
save_image(
self.image_name + "_final2",
self.image2 - self.best_result.watermark * self.watermark_hint)
optimizer.zero_grad()
loss = loss_fn(ae(prior_input), prior_input)
loss.backward()
optimizer.step()
rec_samples.append(ae(prior_input).detach())
img_name = os.path.splitext(os.path.basename(args.img))[0]
img_prior = torch.mean(torch.cat(rec_samples), dim=0).cpu().numpy()
# save prior to output
save_image(img_name, img_prior, args.output_path)
fg = prepare_image(args.fg_hint)
bg = prepare_image(args.bg_hint)
masks = []
for _ in range(5):
s = Segmentation(img_name,
img_prior,
bg_hint=bg,
fg_hint=fg,
plot_during_training=True,
show_every=200,
first_step_iter_num=args.dip_iters // 2,
second_step_iter_num=args.dip_iters,
output_path=args.output_path)