def resolve_and_plot(lr_image_path, hr_image_path, save_dir, img_id):
lr = load_image(lr_image_path)
hr = load_image(hr_image_path)
pre_sr = resolve_single(pre_generator, lr)
gan_sr = resolve_single(gan_generator, lr)
save_image(pre_sr, save_dir, 'resolved_SRResNet', str(img_id))
save_image(gan_sr, save_dir, 'resolved_SRGAN', str(img_id))
images = [lr, hr, pre_sr, gan_sr]
titles = [
'Low Resolution', 'High Resolution', 'Super Resolution (PRE)',
'Super Resolution (GAN)'
]
positions = [1, 2, 3, 4]
plt.figure(figsize=(20, 20))
for i, (img, title, pos) in enumerate(zip(images, titles, positions)):
plt.subplot(2, 2, pos)
# plt.imshow(img)
plt.title(title)
plt.xticks([])
plt.yticks([])
plt.savefig(
os.path.join(save_dir, 'comparison_plots',
'test_img_' + str(img_id) + '.png'))
plt.close()
def test(depth,scale,inputs_path,outputs_path,is_validate,weight_file):
weights_dir = f'weights/edsr-{depth}-x{scale}'
weights_file = os.path.join(weights_dir, weight_file)
model = edsr(scale=scale, num_res_blocks=depth)
model.load_weights(weights_file)
print("[*] weights loaded: ",weight_file)
if(is_validate==0):
print("[*] inferring, scale = ",scale)
image_path_list = get_image_path(inputs_path)
total_num = len(image_path_list)
cnt = 0
for img_path in image_path_list:
t_start = time.time()
cnt += 1
img_name = get_image_name(img_path)
print("[*] processing[%d/%d]:%s"%(cnt,total_num,img_name))
lr_img = load_image(img_path)
print(" [*] low res image shape = ",lr_img.shape)
sr_img = resolve_single(model, lr_img)
# sr_img = tensor2img(model(lr_img[np.newaxis, :] / 255))
img_name_before, img_name_after = divide_image_name(img_name)
output_img_name = img_name_before + "_EDSR_4x" + img_name_after
output_img_path = os.path.join(outputs_path, output_img_name)
outputs_img = sr_img
print("output_img_name = ",output_img_name)
cv2.imwrite(output_img_path, outputs_img)
t_end = time.time()
print(" [*] done! Time = %.1fs"%(t_end - t_start))
else:
print(" image_name PSNR/SSIM PSNR/SSIM (higher,better)")
image_path_list = get_image_path(inputs_path)
for img_path in image_path_list:
img_name = get_image_name(img_path)
raw_img = cv2.imread(img_path)
# Generate low resolution image with original images
lr_img, hr_img = create_lr_hr_pair(raw_img, 4) # scale=4
sr_img = resolve_single(model, lr_img)
bic_img = imresize_np(lr_img, 4).astype(np.uint8)
str_format = " [{}] Bic={:.2f}db/{:.2f}, SR={:.2f}db/{:.2f}"
sr_img = sr_img.numpy()
b = rgb2ycbcr(sr_img)
print(str_format.format(
img_name + ' ' * max(0, 20 - len(img_name)),
calculate_psnr(rgb2ycbcr(bic_img), rgb2ycbcr(hr_img)),
calculate_ssim(rgb2ycbcr(bic_img), rgb2ycbcr(hr_img)),
calculate_psnr(rgb2ycbcr(sr_img), rgb2ycbcr(hr_img)),
calculate_ssim(rgb2ycbcr(sr_img), rgb2ycbcr(hr_img))))
img_name_before, img_name_after = divide_image_name(img_name)
output_img_name = img_name_before + "_ESRGAN_025x_4x" + img_name_after
output_img_path = os.path.join(outputs_path, output_img_name)
# outputs_img = np.concatenate((bic_img, sr_img, hr_img), 1)
outputs_img = sr_img
# cv2.imwrite(output_img_path, outputs_img) # write super resoltion images
img_name_before, img_name_after = divide_image_name(img_name)
output_img_name = img_name_before + "_ESRGAN_025x" + img_name_after
output_lr_img_path = os.path.join(outputs_path, output_img_name)
outputs_lr_img = lr_img
def upscale_image(filePath, model):
image = np.asarray(Image.open(filePath).convert('RGB'))
upscaled = resolve_single(model, image)
upscaled_resized = Image.fromarray(np.asarray(upscaled)).resize((256, 256))
upscaled_resized = np.asarray(upscaled_resized)
upscaled_second = resolve_single(model, upscaled_resized)
image_processed = Image.fromarray(np.asarray(upscaled_second)).convert('L')
image_processed.save(filePath)
def main():
try:
LR_VID_LOCATION = sys.argv[1]
except AssertionError as e:
# Low resolution video path must be provided in first argument.
print(e)
try:
HR_VID_LOCATION = sys.argv[2]
except AssertionError as e:
# High resolution video path must be be provided in second argument
print(e)
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices(
'GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus),
"Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
# SRGAN
srgan_model = generator()
srgan_model.load_weights('weights/srgan/gan_generator.h5')
cap = cv2.VideoCapture(LR_VID_LOCATION)
success, frame = cap.read()
if success == True:
upscale = resolve_single(srgan_model, frame)
width = int(upscale.shape[1])
height = int(upscale.shape[0])
dim = (width, height)
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
fps = cap.get(cv2.CAP_PROP_FPS)
out = cv2.VideoWriter(HR_VID_LOCATION, fourcc, fps, dim)
frame = 0
while success == True:
upscale = resolve_single(srgan_model, frame).numpy()
out.write(upscale)
success, frame = cap.read()
print("Buffering Frame:", frame)
frame += 1
cap.release()
out.release()
def resolve_and_tensorboard_plot(our_model,
lr_image_paths,
title='',
make_input_img_bw=False):
samples = []
for lr_image_path in lr_image_paths:
lr = load_image(lr_image_path, make_input_img_bw)
sr = resolve_single(our_model, lr)
samples.append((lr, sr))
fig = plot_samples(samples,
interpolate_lr=True,
input_img_bw=make_input_img_bw)
buf = io.BytesIO()
plt.savefig(buf, format='png')
# Closing the figure prevents it from being displayed directly inside
# the notebook.
plt.close(fig)
buf.seek(0)
# Convert PNG buffer to TF image
image = tf.image.decode_png(buf.getvalue(), channels=4)
# Add the batch dimension
image = tf.expand_dims(image, 0)
with tb_file_writer.as_default():
tf.summary.image(title, image, step=0)
def resolve_and_save(lr_image_path):
lr = load_image(lr_image_path)
# print(lr)
# print(lr.shape)
gan_sr = resolve_single(gan_generator, lr)
img_name = lr_image_path.split('/')[1].split('.')[0]
save_image(gan_sr, 'SR-output/sr_image.png')
def main():
if sys.argv[1]:
LR_IMG_LOCATION = sys.argv[1]
if sys.argv[2]:
HR_IMG_LOCATION = sys.argv[2]
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices(
'GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus),
"Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
# SRGAN
srgan_model = generator()
srgan_model.load_weights('weights/srgan/gan_generator.h5')
low_res = cv2.imread(LR_IMG_LOCATION)
high_res = resolve_single(srgan_model, low_res).numpy()
cv2.imwrite(HR_IMG_LOCATION, high_res, [cv2.IMWRITE_PNG_COMPRESSION, 9])
def test():
model = edsr(scale=scale, num_res_blocks=depth, num_filters=channels)
checkpoint = tf.train.Checkpoint(step=tf.Variable(0),
psnr=tf.Variable(-1.0),
optimizer=Adam(1e-04),
model=model)
checkpoint_manager = tf.train.CheckpointManager(checkpoint=checkpoint,
directory='./ckpt',
max_to_keep=3)
restore(checkpoint, checkpoint_manager)
video_valid = video_ds(subset='valid')
valid_ds = video_valid.dataset(batch_size=1,
random_transform=False,
repeat_count=1)
psnr, ssim = evaluate(checkpoint.model, valid_ds)
print('PSNR:%.3f, SSIM:%.3f' % (psnr, ssim))
psnr_b = bilinear_upscale('../image_240', '../image_960', scale=scale)
print('bilinear upscale PSNR:%.3f' % psnr_b)
lr = load_image('../image_240/frame1500.jpg')
sr = resolve_single(checkpoint.model, lr)
plt.imshow(sr)
plt.show()
def main():
scale = 30
if sys.argv[1]:
scale = int(sys.argv[1])
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices(
'GPU')
print(len(gpus), "Physical GPUs,", len(logical_gpus),
"Logical GPUs")
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
print(e)
# SRGAN
srgan_model = generator()
srgan_model.load_weights('weights/srgan/gan_generator.h5')
cap = cv2.VideoCapture(0)
ret, frame = cap.read()
while (True):
# Get dimentions of cropped image.
width = int(frame.shape[1] * (scale / 100))
height = int(frame.shape[0] * (scale / 100))
dim = (width, height)
# Capture frame-by-frame
ret, frame = cap.read()
# Crop image by scale
crop = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
# Upscale image
upscale = resolve_single(srgan_model, crop).numpy()
# Resize crop and upscaled image to be the same as input image.
width = int(frame.shape[1])
height = int(frame.shape[0])
dim = (width, height)
crop = cv2.resize(crop, dim, interpolation=cv2.INTER_AREA)
upscale = cv2.resize(upscale, dim, interpolation=cv2.INTER_AREA)
# Display the Resulting Frames
cv2.imshow('input', frame)
cv2.imshow('cropped', crop)
cv2.imshow('srgan', upscale)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
def resolve_and_plot(model_fine_tuned, lr_image_path):
lr = load_image(lr_image_path)
sr_ft = resolve_single(model_fine_tuned, lr)
#model_name = model_pre_trained.name.upper()
st.info('Image Uploaded Successfully')
high = sr_ft.numpy()
st.text('Converted High Resolution Image:')
st.image(high,width=300)
link_image2 = Image.fromarray(high)
st.markdown(get_image_download_link(link_image2), unsafe_allow_html=True)
def get_upscaled_frame(self):
success, image = self.video.read()
scale = 30
width = int(image.shape[1] * (scale / 100))
height = int(image.shape[0] * (scale / 100))
dim = (width, height)
crop = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
upscale = resolve_single(srgan_model, crop).numpy()
ret, jpeg = cv2.imencode('.jpg', upscale)
return jpeg.tobytes()
def resolve_and_plot(lr_image_path):
lr = load_image(lr_image_path)
pre_sr = resolve_single(pre_generator, lr)
gan_sr = resolve_single(gan_generator, lr)
plt.figure(figsize=(20, 20))
images = [lr, pre_sr, gan_sr]
titles = ['LR', 'SR (PRE)', 'SR (GAN)']
positions = [1, 3, 4]
for i, (img, title, pos) in enumerate(zip(images, titles, positions)):
plt.subplot(2, 2, pos)
plt.imshow(img)
plt.title(title)
plt.xticks([])
plt.yticks([])
plt.savefig('test.png')
#resolve_and_plot('demo/0869x4-crop.png')
def results():
if request.method == "POST":
if request.files:
file = request.files["file"]
filename = secure_filename(file.filename)
file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(file_path)
image = load_image(file_path)
high_res_np = resolve_single(model, image)
high_res = Image.fromarray(high_res_np.numpy(), 'RGB')
high_res.save(os.path.join(OUTPUT_FOLDER, filename))
return render_template('results.html', filename=filename)
def plot_some_tests():
img_address = "../dataset/DIV2K_valid_HR/0892.png"
eval_model = load_pre_trained_model()
img = np.array(Image.open(img_address)).astype(float)
h, w, _ = img.shape
cv2.imwrite("data.png", img)
translat = [0, 0.25, 1]
for i, t in enumerate(translat):
img_test = ffttranslate(img, t)
img_test = down_sampling(img_test)
pred = K.eval(resolve_single(eval_model, img_test))
pred2 = cv2.resize(img_test, (w, h), interpolation=cv2.INTER_CUBIC)
cv2.imwrite("VT_" + str(t) + ".png", img_test)
cv2.imwrite("Pred_" + str(t) + ".png", pred)
cv2.imwrite("base_" + str(t) + ".png", pred2)
def generateSR(lr_image_path):
lr = np.array(Image.open(lr_image_path))
sr = resolve_single(model, lr)
img = Image.fromarray(sr.numpy(), 'RGB')
n = img.size
name = input("Enter image name : ")
ext = int(input("Choose format option 1 or 2 ( 1 -> .jpg , 2 -> .png) : "))
if ext == 1:
img.save("./outputs/" + name + ".jpg")
print("Image saved at ./outputs/" + name + ".jpg")
elif ext == 2:
img.save("./outputs/" + name + ".png")
print("Image saved at ./outputs/" + name + ".png")
else:
print("Invalid option. Choosing .png as default...")
img.save("./outputs/" + name + ".png")
print("Image saved at ./outputs/" + name + ".png")
def resolve_and_plot(self, lr_image_path, idx):
lr = load_image(lr_image_path + '.png')
pre_sr = resolve_single(self.checkpoint.model, lr)
#gan_sr = resolve_single(gan_generator, lr)
plt.figure(figsize=(20, 20))
images = [lr, pre_sr]
titles = ['LR', 'SR (PRE)']
positions = [1, 3]
for i, (img, title, pos) in enumerate(zip(images, titles, positions)):
plt.subplot(2, 2, pos)
plt.imshow(img)
plt.title(title)
plt.xticks([])
plt.yticks([])
plt.savefig('%s_%d.png' % (lr_image_path, idx))
def resolve_and_plot(self, lr, fileName):
gan_sr = resolve_single(self.gan_generator, lr)
plt.imshow(gan_sr, interpolation='nearest')
plt.axis('off')
print('File name si ----------', fileName)
plt.savefig(os.path.join(self.CWD_PATH, 'demo', 'HighQuality',
fileName),
dpi=None,
facecolor='w',
edgecolor='w',
orientation='portrait',
papertype='legal',
format=None,
transparent=False,
bbox_inches='tight',
pad_inches=0.0,
frameon=None,
metadata=None)
gan_sr = open(
os.path.join(self.CWD_PATH, 'demo', 'HighQuality', fileName), "rb")
return gan_sr.read()
def generate():
global gan_generator
imgData = request.get_data()
with open("input.png", 'wb') as output:
output.write(imgData)
lr = load_image("input.png")
gan_sr = resolve_single(gan_generator, lr)
epoch_time = int(time.time())
outputfile = 'output_%s.png' % (epoch_time)
imsave(outputfile, gan_sr.numpy())
response = {'result': outputfile}
return jsonify(response)
def supres_generator(list_of_param_dict):
import tensorflow as tf
import os
import numpy as np
physical_devices = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(physical_devices[0], True)
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
from model import generator
from model import resolve_single
from skimage.transform import rescale
from skimage.filters import unsharp_mask
weights_dir = 'weights'
path_file = lambda dirr, filename: os.path.join(dirr, filename)
pre_generator = generator()
gan_generator = generator()
pre_generator.load_weights(path_file(weights_dir, 'pre_generator.h5'))
gan_generator.load_weights(path_file(weights_dir, 'gan_generator.h5'))
for param_dict in list_of_param_dict:
rgb5 = (rescale(unsharp_mask(
resolve_single(pre_generator, param_dict['rgb_10']),
radius=3,
amount=1,
multichannel=True,
),
0.5,
multichannel=True,
anti_aliasing=True) * 255).astype('uint8')
rgb5 = np.clip(rgb5, 1, 255)
transf_rgb5 = list(param_dict['transf_10'])
transf_rgb5[0] *= 0.5
transf_rgb5[4] *= 0.5
param_dict['rgb_5'] = rgb5
param_dict['transf_5'] = transf_rgb5
yield param_dict
from model import resolve_single
from utils import load_image
import tensorflow as tf
import cv2
from model.srgan import generator, discriminator
from model import resolve_single
from utils import load_image
import PIL
from PIL import Image
from tensorflow.python.types import core as core_tf_types
weights_dir = 'weights/srgan'
weights_file = lambda filename: os.path.join(weights_dir, filename)
os.makedirs(weights_dir, exist_ok=True)
gan_generator = generator()
gan_generator.load_weights(weights_file('gan_generator.h5'))
frame_number = 0
folder = r"C:\Users\Hari\Desktop\super-resolution-master\data"
current_path = "C:\\Users\\Hari\\Desktop\\super-resolution-master\\save\\"
for filename in os.listdir(folder):
frame_number += 1
print(frame_number)
lr = load_image(os.path.join(folder, filename))
gan_sr = resolve_single(gan_generator, lr)
tf.keras.preprocessing.image.save_img(
current_path + str(frame_number) + ".png", gan_sr)
#save = cv2.resize(lr, (100,100))
#cv2.imwrite(current_path + str(frame_number) + ".png",save)
def resolve_and_plot(model, lr):
sr_pt = resolve_single(model, lr)
return sr_pt
def run(args):
args = parse_args(args)
if args.image_path is not None:
input_images = process_image(args.image_path, args.resolution)
latentgan_model = None
else:
input_images = None
print(
"WARNING: no input image directory specified, embeddings will be sampled using Laten GAN"
)
latentgan_model = LatentGAN.load(args.latent_gan_model_path)
confignet_model = ConfigNet.load(args.confignet_model_path)
#basic_ui = BasicUI(confignet_model)
# Sample latent embeddings from input images if available and if not sample from Latent GAN
current_embedding_unmodified, current_rotation, orig_images = get_new_embeddings(
input_images, latentgan_model, confignet_model)
# Set next embedding value for rendering
if args.enable_sr == 1:
modelSR = generator()
modelSR.load_weights('evaluation/weights/srgan/gan_generator.h5')
yaw_min_angle = -args.max_angle
pitch_min_angle = -args.max_angle
yaw_max_angle = args.max_angle
pitch_max_angle = args.max_angle
delta_angle = 5
rotation_offset = np.zeros((1, 3))
eye_rotation_offset = np.zeros((1, 3))
facemodel_param_names = list(
confignet_model.config["facemodel_inputs"].keys())
# remove eye rotation as in the demo it is controlled separately
eye_rotation_param_idx = facemodel_param_names.index(
"bone_rotations:left_eye")
facemodel_param_names.pop(eye_rotation_param_idx)
render_input_interp_0 = current_embedding_unmodified
render_input_interp_1 = current_embedding_unmodified
interpolation_coef = 0
if not os.path.exists(dataset_directory):
os.makedirs(dataset_directory)
# This interpolates between the previous and next set embeddings
current_renderer_input = render_input_interp_0 * (
1 - interpolation_coef) + render_input_interp_1 * interpolation_coef
# Set eye gaze direction as controlled by the user
current_renderer_input = set_gaze_direction_in_embedding(
current_renderer_input, eye_rotation_offset, confignet_model)
# all angles
#image = Image.open(args.image_path)
#print(np.array(image))
#return
i = 1
print('All angles')
for yaw in range(yaw_min_angle, yaw_max_angle + 1, delta_angle):
for pitch in range(pitch_min_angle, pitch_max_angle + 1, delta_angle):
rotation_offset[0, 0] = to_rad(yaw)
rotation_offset[0, 1] = to_rad(pitch)
generated_imgs = confignet_model.generate_images(
current_renderer_input, current_rotation + rotation_offset)
if args.enable_sr == 1:
img = cv2.resize(generated_imgs[0], (256, 256))
sr_img = resolve_single(modelSR, img)
cv2.imwrite(dataset_directory + '/%d_%d.png' % (yaw, pitch),
np.array(sr_img))
else:
img = cv2.resize(generated_imgs[0], (1024, 1024))
cv2.imwrite(dataset_directory + '/%d_%d.png' % (yaw, pitch),
img)
print(i)
i += 1
#all random
# 100 картинок со случайными поворотами от -20 до 20, поворотами глаз, выражений лица
print('All random')
current_attribute_name = facemodel_param_names[1] #blendshape_values
frame_embedding = render_input_interp_0 * (
1 - interpolation_coef) + render_input_interp_1 * interpolation_coef
for i in range(100):
eye_rotation_offset[0, 2] = to_rad(np.random.randint(-40, 40))
eye_rotation_offset[0, 0] = to_rad(np.random.randint(-40, 40))
rotation_offset[0, 0] = to_rad(np.random.randint(-20, 20))
rotation_offset[0, 1] = to_rad(np.random.randint(-20, 20))
frame_embedding = set_gaze_direction_in_embedding(
frame_embedding, eye_rotation_offset, confignet_model)
new_embedding_value = get_embedding_with_new_attribute_value(
current_attribute_name, frame_embedding, confignet_model)
generated_imgs = confignet_model.generate_images(
new_embedding_value, current_rotation + rotation_offset)
if args.enable_sr == 1:
img = cv2.resize(generated_imgs[0], (256, 256))
sr_img = resolve_single(modelSR, img)
cv2.imwrite(dataset_directory + '/random_%d.png' % (i),
np.array(sr_img))
else:
img = cv2.resize(generated_imgs[0], (1024, 1024))
cv2.imwrite(dataset_directory + '/random_%d.png' % (i), img)
print(i)
def func(fn_img, fn_model, psf=None,
fn_img_hr=None, suptitle=None,
fnfigout='test.pdf', vm=75, nbit=8):
if fn_img.endswith('npy'):
datalr = np.load(fn_img)[:, :]
elif fn_img.endswith('png'):
try:
datalr = load_image(fn_img)
except:
datalr = load_image('demo/0851x4-crop.png')
else:
print('Do not recognize input image file type, exiting')
exit()
# datalr = hr2lr.normalize_data(datalr, nbit=nbit)
if fn_img_hr!=None:
if fn_img_hr.endswith('.npy'):
datahr = np.load(fn_img_hr)
elif fn_img_hr.endswith('png'):
datahr = load_image(fn_img_hr)
else:
datahr = None
if psf is not None:
if datahr is None:
pass
print("Convolving data")
if psf in ('gaussian','Gaussian'):
kernel1D = signal.gaussian(8, std=1).reshape(8, 1)
kernel = np.outer(kernel1D, kernel1D)
elif psf.endswith('.npy'):
kernel = np.load(psf)
nkern = len(kernel)
kernel = kernel[nkern//2-256:nkern//2+256, nkern//2-256:nkern//2+256]
else:
print("Can't interpret kernel")
exit()
plt.figure()
plt.subplot(121)
plt.imshow(datahr, vmax=25, vmin=5)
datalr = hr2lr.convolvehr(datahr, kernel, rebin=1)
datahr = hr2lr.normalize_data(datahr, nbit=nbit)
plt.subplot(122)
print(datalr.shape)
datalr = hr2lr.normalize_data(datalr, nbit=nbit)
plt.imshow(datalr, vmax=50, vmin=20)
plt.show()
else:
print("Assuming data is already convolved")
model = wdsr_b(scale=4, num_res_blocks=32)
model.load_weights(fn_model)
datalr = datalr[:,:,None]
if nbit==8:
datasr = resolve_single(model, datalr)
else:
datasr = resolve_single16(model, datalr)
plotter(datalr, datasr, datahr=datahr,
suptitle=suptitle, fnfigout=fnfigout, vm=vm,
nbit=nbit)
def test_sub_pix_translation(translat):
"""
To define the tests run by this function we note P the prediction function, the ground truth image G
and I the downsampled image from G.
We note G_t the image the translated image G by t on the horizontal axis and I_t the downsampled image from G_t.
sc = || G - P(I) ||
sc_tr = || G_t - P(I_t) ||
sc_mu = || P(I_t) - P(I) ||
sc_tau = || P(I_t)_(-t) - P(I) ||
best_tau = min || P(I_t)_(t') - P(I) ||
the minimum is searched over t'.
Args :
- translat (float): value of t
Output :
- average of the previous scores
"""
eval_model = load_pre_trained_model()
_, test_ground_truth = dataset.images_paths()
score = []
score_tr = []
score_tr_tr = []
score_mutuel = []
score_mutuel2 = []
score_tau = []
best_tau = []
for ind in range(len(test_ground_truth)):
img = np.array(Image.open(test_ground_truth[ind])).astype(float)
h, w, _ = img.shape
img_ground_truth = img
img_test = down_sampling(img_ground_truth)
prediction = resolve_single(eval_model, img_test)
prediction = K.eval(prediction).astype(float)
score.append(np.sqrt(np.mean((prediction - img_ground_truth)**2)))
img_ground_truth_t = ffttranslate(img_ground_truth, translat)
img_test_t = down_sampling(img_ground_truth_t)
prediction2 = resolve_single(eval_model, img_test_t)
prediction2 = K.eval(prediction2).astype(float)
score_tr.append(np.sqrt(np.mean(
(prediction2 - img_ground_truth_t)**2)))
score_mutuel.append(np.sqrt(np.mean((prediction2 - prediction)**2)))
prediction_tau = ffttranslate(prediction2, -translat)
score_mutuel2.append(
np.sqrt(np.mean((prediction2 - prediction_tau)**2)))
score_tau.append(np.sqrt(np.mean((prediction_tau - prediction)**2)))
score_tr_tr.append(
np.sqrt(np.mean((prediction_tau - img_ground_truth)**2)))
func = lambda x: np.mean(
(ffttranslate(prediction2, -x) - prediction)**2)
tau_opt = opt.minimize(func, translat)
best_tau.append(tau_opt.x)
print(
"t = %f - testing pre-trained model %i/%i : score - %f ; score tr - %f ; score mutuel - %f ; score translation inv - %f ; best tau - %f"
% (translat, ind, len(test_ground_truth), score[-1], score_tr[-1],
score_mutuel[-1], score_tau[-1], best_tau[-1]))
return np.mean(score), np.mean(score_tr), np.mean(score_tr_tr), np.mean(
score_mutuel), np.mean(score_mutuel2), np.mean(score_tau), np.mean(
best_tau), np.std(best_tau)
model = generator()
model.load_weights('weights/srgan/gan_generator.h5')
#lr = utils.load_image('demo/0805x4-crop.png')
#sr = resolve_single(model, lr)
#utils.plot_sample(lr, sr)
cap = cv2.VideoCapture(video)
ret, frame = cap.read()
scale = 30
width = int(frame.shape[1] * (scale / 100))
height = int(frame.shape[0] * (scale / 100))
dim = (width, height)
crop = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
upscale = resolve_single(model, crop).numpy()
print("Upscale Width: {}".format(upscale.shape[1]))
print("Upscale Height: {}".format(upscale.shape[0]))
crop_out = cv2.VideoWriter('Outputs/crop.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, dim)
upscale_out = cv2.VideoWriter('Outputs/upscale.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30,
(upscale.shape[1], upscale.shape[0]))
i = 1
while (True):
# Capture frame-by-frame
ret, frame = cap.read()
if ret == True:
crop = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
def resolve_and_plot(lr_image_path):
lr = load_image(lr_image_path)
#plot_sample_no_treatment(lr)
sr = resolve_single(model,lr)
plot_sample(lr,sr)
from model import resolve_single
from model.edsr import edsr
from utils import load_image, plot_sample
model = edsr(scale=4, num_res_blocks=16)
model.load_weights('weights/edsr-16-x4/weights.h5')
lr = load_image('demo/frame-1214_frame_blend')
sr = resolve_single(model, lr)
plot_sample(lr, sr)
def Use_SRGAN():
model = generator()
model.load_weights('weights/srgan/gan_generator.h5')
lr = Load_Image(filename)
sr = resolve_single(model, lr)
Save_Image(sr)
def Use_WDSR():
model = wdsr_b(scale=4, num_res_blocks=32)
model.load_weights('weights/wdsr-b-32-x4/weights.h5')
lr = Load_Image(filename)
sr = resolve_single(model, lr)
Save_Image(sr)
def Use_EDSR():
model = edsr(scale=4, num_res_blocks=16)
model.load_weights('weights/edsr-16-x4/weights.h5')
lr = Load_Image(filename)
sr = resolve_single(model, lr)
Save_Image(sr)
