def image_quality_evaluation(sr_filename: str, hr_filename: str, device: torch.device = "cpu"):
"""Image quality evaluation function.
Args:
sr_filename (str): Image file name after super resolution.
hr_filename (str): Original high resolution image file name.
device (optional, torch.device): Selection of data processing equipment in PyTorch. (Default: ``cpu``).
Returns:
If the `simple` variable is set to ``False`` return `mse, rmse, psnr, ssim, msssim, niqe, sam, vifp, lpips`,
else return `psnr, ssim`.
"""
# Reference sources from `https://github.com/richzhang/PerceptualSimilarity`
lpips_loss = lpips.LPIPS(net="vgg", verbose=False).to(device)
# Evaluate performance
sr = cv2.imread(sr_filename)
hr = cv2.imread(hr_filename)
# For LPIPS evaluation
sr_tensor = opencv2tensor(sr, device)
hr_tensor = opencv2tensor(hr, device)
# Complete estimate.
mse_value = mse(sr, hr)
rmse_value = rmse(sr, hr)
psnr_value = psnr(sr, hr)
ssim_value = ssim(sr, hr)
msssim_value = msssim(sr, hr)
niqe_value = niqe(sr_filename)
sam_value = sam(sr, hr)
vifp_value = vifp(sr, hr)
lpips_value = lpips_loss(sr_tensor, hr_tensor)
return mse_value, rmse_value, psnr_value, ssim_value, msssim_value, niqe_value, sam_value, vifp_value, lpips_value
def obtain_similarity_metrics(GT_img, distorted_img):
# MEAN SQUARED ERROR
mse_value = mse(GT_img, distorted_img)
# STRUCTURAL SIMILARITY
ssim_value = ssim(GT_img, distorted_img)
# PEAK SIGNAL TO NOISE RATIO
psnr_value = psnr(GT_img, distorted_img)
# ROOT MEAN SQUARED ERROR
rmse_value = rmse(GT_img, distorted_img)
# VISUAL INFORMATION FIDELITY
vif_value = vifp(GT_img, distorted_img)
# UNIVERSAL IMAGE QUALITY INDEX
uqi_value = uqi(GT_img, distorted_img)
# MULTI-SCALE STRUCTURAL SIMILARITY INDEX
msssim_value = msssim(GT_img, distorted_img)
# PSNR-HVS-M & PSNR-HVS
p_hvs_m, p_hvs = psnrhmam.color_psnrhma(GT_img, distorted_img)
return mse_value, ssim_value, psnr_value, rmse_value, vif_value, uqi_value, msssim_value, p_hvs_m, p_hvs
def quality(X_ori, Y_cmp, ws=8, MAX=255):
'''
Use MS-SSIM to calcualte the compression quality.
Shift the pixel range up by 128 and then clip to
[0, 255] before the algorithm. Returns a score
in [0, 1]. A higher score suggests better quality.
Parameters:
X_ori: original image
Y_cmp: compressed image
ws: sliding window size (default 8)
MAX: maximum value of datarange (default 255)
Return: a float in [0, 1].
Reference:
"Multiscale structural similarity for image quality assessment." (2003)
https://ieeexplore.ieee.org/abstract/document/1292216/
'''
X_ori, Y_cmp = [np.clip(np.round(X) + 128, 0, 255) for X in [X_ori, Y_cmp]]
return msssim(X_ori, Y_cmp, ws=ws, MAX=MAX).real
def get_bpg_df(directory,
write_files=False,
effective_bytes=True,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for BPG. The result is saved
as a CSV file in the source directory. If the file exists, the DF is loaded and returned.
The files are saved using the reference codec: https://bellard.org/bpg/
"""
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astypre(np.float32) / (2**8 - 1)
quality_levels = np.arange(10, 40, 1)
df_jpeg_path = os.path.join(directory, 'bpg.csv')
if os.path.isfile(df_jpeg_path) and not force_calc:
logger.info('Restoring BPG stats from {}'.format(df_jpeg_path))
df = pd.read_csv(df_jpeg_path, index_col=False)
else:
df = pd.DataFrame(columns=[
'image_id', 'filename', 'codec', 'quality', 'ssim', 'psnr',
'msssim', 'msssim_db', 'bytes', 'bpp'
])
with tqdm.tqdm(total=len(files) * len(quality_levels),
ncols=120,
desc='BPG') as pbar:
for image_id, filename in enumerate(files):
# Read the original image
image = batch_x[image_id]
for qi, q in enumerate(quality_levels):
# Compress to BPG
# Save as temporary file
imageio.imwrite('/tmp/image.png',
(255 * image).astype(np.uint8))
bpp_path = bpg_helpers.bpg_compress(
'/tmp/image.png', q, '/tmp')
image_compressed = imageio.imread(
bpg_helpers.decode_bpg_to_png(bpp_path)).astype(
np.float) / (2**8 - 1)
if effective_bytes:
bpp = bpg_helpers.bpp_of_bpg_image(bpp_path)
image_bytes = round(bpp * image.shape[0] *
image.shape[1] / 8)
else:
image_bytes = os.stat(bpp_path).st_size
bpp = 8 * image_bytes / image.shape[0] / image.shape[1]
if write_files:
image_dir = os.path.join(directory,
os.path.splitext(filename)[0])
if not os.path.isdir(image_dir):
os.makedirs(image_dir)
image_path = os.path.join(image_dir,
'bpg_q{:03d}.png'.format(q))
imageio.imwrite(image_path,
(255 * image_compressed).astype(
np.uint8))
msssim_value = msssim(image, image_compressed, MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'codec':
'bpg',
'quality':
q,
'ssim':
compare_ssim(image,
image_compressed,
multichannel=True,
data_range=1),
'psnr':
compare_psnr(image, image_compressed,
data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
'bytes':
image_bytes,
'bpp':
bpp
},
ignore_index=True)
pbar.set_postfix(image_id=image_id, quality=q)
pbar.update(1)
df.to_csv(df_jpeg_path, index=False)
return df
def get_jpeg2k_df(directory,
write_files=False,
effective_bytes=True,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for JPEG 2000. The result is saved
as a CSV file in the source directory. If the file exists, the DF is loaded and returned.
Files are saved as JPEG using glymur.
"""
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astype(np.float32) / (2**8 - 1)
# Get trade-off for JPEG
quality_levels = np.arange(25, 45, 1)
df_jpeg_path = os.path.join(directory, 'jpeg2000.csv')
if os.path.isfile(df_jpeg_path) and not force_calc:
logger.info('Restoring JPEG 2000 stats from {}'.format(df_jpeg_path))
df = pd.read_csv(df_jpeg_path, index_col=False)
else:
df = pd.DataFrame(columns=[
'image_id', 'filename', 'codec', 'quality', 'ssim', 'psnr',
'msssim', 'msssim_db', 'bytes', 'bpp'
])
with tqdm.tqdm(total=len(files) * len(quality_levels),
ncols=120,
desc='JP2k') as pbar:
for image_id, filename in enumerate(files):
# Read the original image
image = batch_x[image_id]
for qi, q in enumerate(quality_levels):
# TODO Use Glymur to save JPEG 2000 images to a temp file
image_np = (255 * image.clip(0, 1)).astype(np.uint8)
glymur.Jp2k('/tmp/image.jp2', data=image_np, psnr=[q])
if effective_bytes:
image_bytes = jpeg_helpers.jp2bytes('/tmp/image.jp2')
else:
image_bytes = os.path.getsize('/tmp/image.jp2')
image_compressed = imageio.imread('/tmp/image.jp2').astype(
np.float) / (2**8 - 1)
# TODO Use Pillow to save JPEG 2000 images to a memory buffer
# TODO This has been disabled = their implementation seems to be invalid
# with io.BytesIO() as output:
# image_pillow = PIL.Image.fromarray((255*image.clip(0, 1)).astype(np.uint8))
# image_pillow.save(output, format='jpeg2000', quality_layers=[q])
# image_compressed = imageio.imread(output.getvalue()).astype(np.float) / (2**8 - 1)
# image_bytes = len(output.getvalue())
if write_files:
image_dir = os.path.join(directory,
os.path.splitext(filename)[0])
if not os.path.isdir(image_dir):
os.makedirs(image_dir)
image_path = os.path.join(
image_dir, 'jp2_q{:.1f}dB.png'.format(q))
imageio.imwrite(image_path,
(255 * image_compressed).astype(
np.uint8))
msssim_value = msssim(image, image_compressed, MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'codec':
'jpeg2000',
'quality':
q,
'ssim':
compare_ssim(image,
image_compressed,
multichannel=True,
data_range=1),
'psnr':
compare_psnr(image, image_compressed,
data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
'bytes':
image_bytes,
'bpp':
8 * image_bytes / image.shape[0] / image.shape[1]
},
ignore_index=True)
pbar.set_postfix(image_id=image_id, quality=q)
pbar.update(1)
df.to_csv(df_jpeg_path, index=False)
return df
def get_jpeg_df(directory,
write_files=False,
effective_bytes=True,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for JPEG. The result is saved
as a CSV file in the source directory. If the file exists, the DF is loaded and returned.
Files are saved as JPEG using imageio.
"""
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astype(np.float32) / (2**8 - 1)
# Get trade-off for JPEG
quality_levels = np.arange(95, 5, -5)
df_jpeg_path = os.path.join(directory, 'jpeg.csv')
if os.path.isfile(df_jpeg_path) and not force_calc:
logger.info('Restoring JPEG stats from {}'.format(df_jpeg_path))
df = pd.read_csv(df_jpeg_path, index_col=False)
else:
df = pd.DataFrame(columns=[
'image_id', 'filename', 'codec', 'quality', 'ssim', 'psnr',
'msssim', 'msssim_db', 'bytes', 'bpp'
])
with tqdm.tqdm(total=len(files) * len(quality_levels),
ncols=120,
desc='JPEG') as pbar:
for image_id, filename in enumerate(files):
# Read the original image
image = batch_x[image_id]
for qi, q in enumerate(quality_levels):
# Compress images and get effective bytes (only image data - no headers)
image_compressed, image_bytes = jpeg_helpers.compress_batch(
image, q, effective=effective_bytes)
if write_files:
image_dir = os.path.join(directory,
os.path.splitext(filename)[0])
if not os.path.isdir(image_dir):
os.makedirs(image_dir)
image_path = os.path.join(image_dir,
'jpeg_q{:03d}.png'.format(q))
imageio.imwrite(image_path,
(255 * image_compressed).astype(
np.uint8))
msssim_value = msssim(image, image_compressed, MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'codec':
'jpeg',
'quality':
q,
'ssim':
compare_ssim(image,
image_compressed,
multichannel=True,
data_range=1),
'psnr':
compare_psnr(image, image_compressed,
data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
'bytes':
image_bytes,
'bpp':
8 * image_bytes / image.shape[0] / image.shape[1]
},
ignore_index=True)
pbar.set_postfix(image_id=image_id, quality=q)
pbar.update(1)
df.to_csv(os.path.join(directory, 'jpeg.csv'), index=False)
return df
def get_diff_jpeg_df(directory,
write_files=False,
effective_bytes=True,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for diff JPEG. The result is saved
as a CSV file in the source directory. If the file exists, the DF is loaded and returned.
Files are saved as JPEG using imagemagick
"""
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astype(np.float32) / (2**8 - 1)
# Get trade-off for JPEG
alpha_range = np.arange(1000, 100, -100)
quality_levels = np.arange(95, 5, -5)
df_jpeg_path = os.path.join(directory, 'diff_jpeg.csv')
if os.path.isfile(df_jpeg_path) and not force_calc:
print('Restoring diff JPEG stats from {}'.format(df_jpeg_path))
df = pd.read_csv(df_jpeg_path, index_col=False)
else:
df = pd.DataFrame(columns=[
'image_id', 'filename', 'codec', 'quality', 'ssim', 'psnr',
'msssim', 'msssim_db', 'bytes', 'bpp'
])
data = dataset.Dataset(directory,
n_images=1,
v_images=0,
val_n_patches=1,
load='y')
batch_rgb = data.next_training_batch(0, 1, 64)
codec_differentiable = jpeg.JPEG(50, codec='soft', trainable=True)
with tqdm.tqdm(total=len(files) * len(quality_levels),
ncols=120,
desc='JPEG') as pbar:
for image_id, filename in enumerate(files):
for q_i, q in enumerate(quality_levels):
codec_differentiable.quality = q
# Read the original image
image = batch_x[image_id]
luma, chroma = codec_differentiable.train_q_table(
batch_rgb, alpha=1, beta=100, n_times=20)
with open(
'data/diff_jpeg/image1/quantization-table.xml', 'r'
) as input_file, open(
'data/diff_jpeg/image1/quantization-table-diff.xml',
'w') as output_file:
for line in input_file:
xml_data = input_file.readlines()
index_1 = 43
for i in range(0, len(luma.numpy())):
q_table_this_line_luma = luma.numpy()[i]
xml_data[index_1 + i] = " " + str(
int(q_table_this_line_luma[0])) + ", " + str(
int(q_table_this_line_luma[1])
) + ", " + str(int(
q_table_this_line_luma[2])) + ", " + str(
int(q_table_this_line_luma[3])
) + ", " + str(
int(q_table_this_line_luma[4])
) + ", " + str(
int(q_table_this_line_luma[5])
) + ", " + str(
int(q_table_this_line_luma[6])
) + ", " + str(
int(q_table_this_line_luma[7])
) + ", " + "\n"
index_2 = 68
for i in range(0, len(chroma.numpy())):
q_table_this_line_chroma = chroma.numpy()[i]
xml_data[index_2 + i] = " " + str(
int(q_table_this_line_chroma[0])) + ", " + str(
int(q_table_this_line_chroma[1])
) + ", " + str(int(
q_table_this_line_chroma[2])) + ", " + str(
int(q_table_this_line_chroma[3])
) + ", " + str(
int(q_table_this_line_chroma[4])
) + ", " + str(
int(q_table_this_line_chroma[5])
) + ", " + str(
int(q_table_this_line_chroma[6])
) + ", " + str(
int(q_table_this_line_chroma[7])
) + ", " + "\n"
output_file.writelines(xml_data)
# Compress images and get effective bytes (only image data - no headers)
os.system(
'magick convert -quality ' + str(50) +
' -define jpeg:q-table=data/diff_jpeg/image1/quantization-table-diff.xml'
+ ' ' + directory + '/' + filename + ' ' + directory +
'/' + filename + '_' + str(50) + '_compressed.jpeg')
if effective_bytes:
with open(
directory + '/' + filename + "_" + str(50) +
'_compressed.jpeg', 'rb') as fh:
buf = io.BytesIO(fh.read())
image_bytes = JPEGMarkerStats(
buf.getvalue()).get_effective_bytes()
else:
image_bytes = os.path.getsize(directory + '/' +
filename + "_" +
str(50) +
'_compressed.jpeg')
image = imageio.imread(directory + '/' + filename).astype(
np.float) / (2**8 - 1)
image_compressed = imageio.imread(
directory + '/' + filename + "_" + str(50) +
'_compressed.jpeg').astype(np.float) / (2**8 - 1)
image_compressed_path = directory + '/' + filename + "_" + str(
50) + '_compressed.jpeg'
image_path = directory + '/' + filename
if not write_files:
os.remove(directory + '/' + filename + "_" + str(50) +
'_compressed.jpeg')
msssim_value = msssim(image, image_compressed, MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'codec':
'jpeg',
'quality':
q,
'ssim':
compare_ssim(image,
image_compressed,
multichannel=True,
data_range=1),
'psnr':
compare_psnr(image, image_compressed,
data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
#'perceptual similarity': perceptual_similarity,
'bytes':
image_bytes,
'bpp':
8 * image_bytes / image.shape[0] / image.shape[1]
},
ignore_index=True)
pbar.set_postfix(image_id=image_id, quality=q)
pbar.update(1)
df.to_csv(os.path.join(directory, 'diff_jpeg.csv'), index=False)
return df
def get_jpeg_imagemagick_df(directory,
write_files=False,
effective_bytes=True,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for JPEG. The result is saved
as a CSV file in the source directory. If the file exists, the DF is loaded and returned.
Files are saved as JPEG using imageio.
"""
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astype(np.float32) / (2**8 - 1)
# Get trade-off for JPEG
quality_levels = np.arange(95, 5, -5)
df_jpeg_path = os.path.join(directory, 'jpeg.csv')
if os.path.isfile(df_jpeg_path) and not force_calc:
logger.info('Restoring JPEG stats from {}'.format(df_jpeg_path))
df = pd.read_csv(df_jpeg_path, index_col=False)
else:
df = pd.DataFrame(columns=[
'image_id', 'filename', 'codec', 'quality', 'ssim', 'psnr',
'msssim', 'msssim_db', 'bytes', 'bpp'
])
with tqdm.tqdm(total=len(files) * len(quality_levels),
ncols=120,
desc='JPEG') as pbar:
for image_id, filename in enumerate(files):
# Read the original image
image = batch_x[image_id]
for qi, q in enumerate(quality_levels):
os.system(
'magick convert -quality ' + str(q) +
' -define jpeg:q-table=data/diff_jpeg/image1/quantization-table.xml'
+ ' ' + directory + '/' + filename + ' ' + directory +
'/' + filename + '_' + str(q) + '_compressed.jpeg')
if effective_bytes:
with open(
directory + '/' + filename + "_" + str(q) +
'_compressed.jpeg', 'rb') as fh:
buf = io.BytesIO(fh.read())
image_bytes = JPEGMarkerStats(
buf.getvalue()).get_effective_bytes()
else:
image_bytes = os.path.getsize(directory + '/' +
filename + "_" + str(q) +
'_compressed.jpeg')
image = imageio.imread(directory + '/' + filename).astype(
np.float) / (2**8 - 1)
image_compressed = imageio.imread(
directory + '/' + filename + "_" + str(q) +
'_compressed.jpeg').astype(np.float) / (2**8 - 1)
image_compressed_path = directory + '/' + filename + "_" + str(
50) + '_compressed.jpeg'
image_path = directory + '/' + filename
if not write_files:
os.remove(directory + '/' + filename + "_" + str(q) +
'_compressed.jpeg')
msssim_value = msssim(image, image_compressed, MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'codec':
'jpeg',
'quality':
q,
'ssim':
compare_ssim(image,
image_compressed,
multichannel=True,
data_range=1),
'psnr':
compare_psnr(image, image_compressed,
data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
'bytes':
image_bytes,
'bpp':
8 * image_bytes / image.shape[0] / image.shape[1]
},
ignore_index=True)
pbar.set_postfix(image_id=image_id, quality=q)
pbar.update(1)
df.to_csv(os.path.join(directory, 'jpeg.csv'), index=False)
return df
vutils.save_image(lr, "lr.png")
vutils.save_image(sr, "sr.png")
vutils.save_image(hr, "hr.png")
# Evaluate performance
src_img = cv2.imread("sr.png")
dst_img = cv2.imread("hr.png")
# Reference sources from `https://github.com/richzhang/PerceptualSimilarity`
lpips_loss = lpips.LPIPS(net="vgg").to(device)
mse_value = mse(src_img, dst_img)
rmse_value = rmse(src_img, dst_img)
psnr_value = psnr(src_img, dst_img)
ssim_value = ssim(src_img, dst_img)
ms_ssim_value = msssim(src_img, dst_img) # 30.00+000j
niqe_value = cal_niqe("sr.png")
sam_value = sam(src_img, dst_img)
vif_value = vifp(src_img, dst_img)
lpips_value = lpips_loss(sr, hr)
print("\n")
print("====================== Performance summary ======================")
print(
f"MSE: {mse_value:.2f}\n"
f"RMSE: {rmse_value:.2f}\n"
f"PSNR: {psnr_value:.2f}\n"
f"SSIM: {ssim_value[0]:.4f}\n"
f"MS-SSIM: {ms_ssim_value.real:.4f}\n"
f"NIQE: {niqe_value:.2f}\n"
f"SAM: {sam_value:.4f}\n"
print("uqi: ", uqi)
psnr = psnr(img1, img2)
print("psnr: ", psnr)
ssim = ssim(img1, img2)
print("ssim: ", ssim)
mse = mse(img1, img2)
print("mse: ", mse)
rmse_sw = rmse_sw(img1, img2)
# print("rmse_sw: ", rmse_sw)
ergas = ergas(img1, img2)
print("ergas: ", ergas)
scc = scc(img1, img2)
print("scc: ", scc)
rase = rase(img1, img2)
print("ergas: ", rase)
sam = sam(img1, img2)
print("sam: ", sam)
msssim = msssim(img1, img2)
print("msssim: ", msssim)
vifp = vifp(img1, img2)
print("vifp: ", vifp)
def MSSSIM(original_stacked, estimated_stacked, image_size):
estimated1, estimated2 = unflatten(estimated_stacked, image_size)
source1, source2 = unflatten(original_stacked, image_size)
msssim1 = msssim(source1, estimated1, MAX=1)
msssim2 = msssim(source2, estimated2, MAX=1)
return msssim1, msssim2
####################################################################
#Multiscale structural similarity index
"""calculates multi-scale structural similarity index (ms-ssim).
:param GT: first (original) input image.
:param P: second (deformed) input image.
:param weights: weights for each scale (default = [0.0448, 0.2856, 0.3001, 0.2363, 0.1333]).
:param ws: sliding window size (default = 11).
:param K1: First constant for SSIM (default = 0.01).
:param K2: Second constant for SSIM (default = 0.03).
:param MAX: Maximum value of datarange (if None, MAX is calculated using image dtype).
:returns: float -- ms-ssim value.
"""
msssim_img=full_ref.msssim(ref_img, img, weights=[0.0448, 0.2856, 0.3001, 0.2363, 0.1333], ws=11, K1=0.01, K2=0.03, MAX=None)
print("MSSSIM: multi-scale structural similarity index = ", msssim_img)
##############################################################################
#PSNR
"""calculates peak signal-to-noise ratio (psnr).
:param GT: first (original) input image.
:param P: second (deformed) input image.
:param MAX: maximum value of datarange (if None, MAX is calculated using image dtype).
:returns: float -- psnr value in dB.
"""
psnr_img=full_ref.psnr(ref_img, img, MAX=None)
out_img_cb = cb.resize(out_image_y.size, Image.BICUBIC)
out_img_cr = cr.resize(out_image_y.size, Image.BICUBIC)
out_img = Image.merge("YCbCr",
[out_image_y, out_img_cb, out_img_cr]).convert("RGB")
# before converting the result in RGB
out_img.save(f"result/{filename}")
# Evaluate performance
src_img = cv2.imread(f"result/{filename}")
dst_img = cv2.imread(f"{target}/{filename}")
total_mse_value += mse(src_img, dst_img)
total_rmse_value += rmse(src_img, dst_img)
total_psnr_value += psnr(src_img, dst_img)
total_ssim_value += ssim(src_img, dst_img)
total_ms_ssim_value += msssim(src_img, dst_img)
total_niqe_value += cal_niqe(f"result/{filename}")
total_sam_value += sam(src_img, dst_img)
total_vif_value += vifp(src_img, dst_img)
total_file += 1
print(f"Avg MSE: {total_mse_value / total_file:.2f}\n"
f"Avg RMSE: {total_rmse_value / total_file:.2f}\n"
f"Avg PSNR: {total_psnr_value / total_file:.2f}\n"
f"Avg SSIM: {total_ssim_value / total_file:.4f}\n"
f"Avg MS-SSIM: {total_ms_ssim_value / total_file:.4f}\n"
f"Avg NIQE: {total_niqe_value / total_file:.2f}\n"
f"Avg SAM: {total_sam_value / total_file:.4f}\n"
f"Avg VIF: {total_vif_value / total_file:.4f}")
def get_dcn_df(directory,
model_directory,
write_files=False,
force_calc=False):
"""
Compute and return (as Pandas DF) the rate distortion curve for the learned DCN codec.
The result is saved as a CSV file in the source directory. If the file exists, the DF
is loaded and returned.
"""
# Discover test files
files, _ = loading.discover_images(directory, n_images=-1, v_images=0)
batch_x = loading.load_images(files, directory, load='y')
batch_x = batch_x['y'].astype(np.float32) / (2**8 - 1)
# Create a new table for the DCN
df = pd.DataFrame(columns=[
'image_id', 'filename', 'model_dir', 'codec', 'ssim', 'psnr', 'msssim',
'msssim_db', 'entropy', 'bytes', 'bpp', 'layers', 'quantization',
'entropy_reg', 'codebook', 'latent', 'latent_shape', 'n_features'
])
# Discover available models
model_dirs = list(Path(model_directory).glob('**/progress.json'))
logger.info('Found {} models'.format(len(model_dirs)))
df_path = os.path.join(
directory, 'dcn-{}.csv'.format(
[x for x in fsutil.split(model_directory) if len(x) > 0][-1]))
if os.path.isfile(df_path) and not force_calc:
logger.info('Restoring DCN stats from {}'.format(df_path))
df = pd.read_csv(df_path, index_col=False)
else:
for model_dir in model_dirs:
logger.info('Processing model dir: {}'.format(model_dir))
dcn = codec.restore(
os.path.split(str(model_dir))[0], batch_x.shape[1])
# Dump compressed images
for image_id, filename in enumerate(files):
try:
batch_y, image_bytes = codec.simulate_compression(
batch_x[image_id:image_id + 1], dcn)
batch_z = dcn.compress(batch_x[image_id:image_id + 1])
entropy = helpers.stats.entropy(batch_z,
dcn.get_codebook())
except Exception as e:
logger.error(
'Error while processing {} with {} : {}'.format(
filename, dcn.model_code, e))
raise e
if write_files:
image_dir = os.path.join(directory,
os.path.splitext(filename)[0])
if not os.path.isdir(image_dir):
os.makedirs(image_dir)
image_path = os.path.join(
image_dir,
dcn.model_code.replace('/', '-') + '.png')
imageio.imwrite(image_path,
(255 * batch_y[0]).astype(np.uint8))
msssim_value = msssim(batch_x[image_id], batch_y[0],
MAX=1).real
df = df.append(
{
'image_id':
image_id,
'filename':
filename,
'model_dir':
os.path.relpath(
os.path.split(str(model_dir))[0],
model_directory).replace(dcn.scoped_name, ''),
'codec':
dcn.model_code,
'ssim':
compare_ssim(batch_x[image_id],
batch_y[0],
multichannel=True,
data_range=1),
'psnr':
compare_psnr(
batch_x[image_id], batch_y[0], data_range=1),
'msssim':
msssim_value,
'msssim_db':
-10 * np.log10(1 - msssim_value),
'entropy':
entropy,
'bytes':
image_bytes,
'bpp':
8 * image_bytes / batch_x[image_id].shape[0] /
batch_x[image_id].shape[1],
'layers':
dcn.n_layers if 'n_layers' in dcn._h else None,
'quantization':
'{}-{:.0f}bpf'.format(dcn._h.rounding, dcn.latent_bpf),
'entropy_reg':
dcn.entropy_weight,
'codebook':
dcn._h.rounding,
'latent':
dcn.n_latent,
'latent_shape':
'{}x{}x{}'.format(*dcn.latent_shape[1:]),
'n_features':
dcn.latent_shape[-1]
},
ignore_index=True)
df.to_csv(df_path, index=False)
return df
with torch.no_grad():
sr = model(lr)
vutils.save_image(lr, f"./benchmark/lr_{iteration}.bmp")
vutils.save_image(sr, f"./benchmark/sr_{iteration}.bmp")
vutils.save_image(hr, f"./benchmark/hr_{iteration}.bmp")
# Evaluate performance
src_img = cv2.imread(f"./benchmark/sr_{iteration}.bmp")
dst_img = cv2.imread(f"./benchmark/hr_{iteration}.bmp")
mse_value = mse(src_img, dst_img)
rmse_value = rmse(src_img, dst_img)
psnr_value = psnr(src_img, dst_img)
ssim_value = ssim(src_img, dst_img)
ms_ssim_value = msssim(src_img, dst_img)
niqe_value = cal_niqe(f"./benchmark/sr_{iteration}.bmp")
sam_value = sam(src_img, dst_img)
vif_value = vifp(src_img, dst_img)
lpips_value = lpips_loss(sr, hr)
total_mse_value += mse_value
total_rmse_value += rmse_value
total_psnr_value += psnr_value
total_ssim_value += ssim_value[0]
total_ms_ssim_value += ms_ssim_value.real
total_niqe_value += niqe_value
total_sam_value += sam_value
total_vif_value += vif_value
total_lpips_value += lpips_value.item()
def main_function(file_name1, file_name2, no):
global file_name_upscaled
global file_save_name
# Second window created
top = Toplevel()
top.title("second window")
top.configure(bg="#333333")
# read passed images
img = cv2.imread(file_name1)
ref_img = cv2.imread(file_name2)
"""
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Interpolation
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
"""
# Linear interpolation
if no == 0:
img_int = cv2.resize(img,(384,384),fx=0,fy=0, interpolation = cv2.INTER_LINEAR)
file_save_name = 'linear_interpolation.png'
cv2.imwrite(file_save_name, img_int)
# Bicubic interpolation
elif no == 1:
img_int = cv2.resize(img,(384,384),fx=0,fy=0, interpolation = cv2.INTER_CUBIC)
file_save_name = 'bicubic_interpolation.png'
cv2.imwrite(file_save_name, img_int)
# Lanczos Interpolation
elif no == 2:
img_int = cv2.resize(img,(384,384),fx=0,fy=0, interpolation = cv2.INTER_LANCZOS4)
file_save_name = 'Lanczos.png'
cv2.imwrite(file_save_name, img_int)
# Nearest Neighbor Interpolation
elif no == 3:
img_int = cv2.resize(img,(384,384),fx=0,fy=0, interpolation = cv2.INTER_NEAREST)
file_save_name = 'Nearest.png'
cv2.imwrite(file_save_name, img_int)
# Pixel area Resampling
elif no == 4:
img_int = cv2.resize(img,(384,384),fx=0,fy=0, interpolation = cv2.INTER_AREA)
file_save_name = 'pixel.png'
cv2.imwrite(file_save_name, img_int)
elif no == 5:
pass
else:
pass
"""
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Designing TKINTER GUI
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
"""
# display labels
label_HR = Label(top, text="HR Image", bg="#333333", fg="#fff")
label_HR.grid(row=0, column=2)
label_LR = Label(top, text="LR Image", bg="#333333", fg="#fff")
label_LR.grid(row=0, column=0)
label_Upscaled = Label(top, text="Upscaled Image", bg="#333333", fg="#fff")
label_Upscaled.grid(row=0, column=1)
# display the image
# display HR image
disp_HR = ImageTk.PhotoImage(Image.open(file_name2))
label_HR_img = Label(top, image = disp_HR, bg="#333333", fg="#fff")
label_HR_img.grid(row=1, column=2)
# display LR image
disp_LR = ImageTk.PhotoImage(Image.open(file_name1))
label_LR_img = Label(top, image = disp_LR, bg="#333333", fg="#fff")
label_LR_img.grid(row=1, column=0)
# display upscaled image
file_name_upscaled = os.path.abspath(file_save_name)
disp = ImageTk.PhotoImage(Image.open(file_name_upscaled))
label_1 = Label(top, image=disp, bg="#333333", fg="#fff")
label_1.grid(row=1, column=1)
# calculate the MS-SSIM and DISTS
msssim_img= full_ref.msssim(ref_img, img_int, weights=[0.0448, 0.2856, 0.3001, 0.2363, 0.1333], ws=11, K1=0.01, K2=0.03, MAX=None)
dists_img = arguments(file_name2, file_name_upscaled)
# display the calculated error
label_msssim = Label(top, text = "MS-SSIM: "+str(msssim_img.real), bg="#333333", fg="#fff")
label_msssim.grid(row=2, column=0, columnspan=2)
print(msssim_img.real)
label_dists = Label(top, text = "DISTS: "+str(dists_img), bg="#333333", fg="#fff")
label_dists.grid(row=2, column=2)
print(dists_img)
label_msssim.config(font=("Courier", 18))
label_dists.config(font=("Courier", 18))
# end of program
mainloop()
for i in total_files:
f_name = str(i).split('.')[0]
img_clean = cv2.imread(clean_dir + str(f_name) + '.jpg')
img_pred = cv2.imread(result_dir + str(f_name) + '.png')
uq = uqi(img_clean, img_pred)
uqi_list.append(uq)
ms = mse(img_clean, img_pred)
mse_list.append(ms)
vi = vifp(img_clean, img_pred)
vif_list.append(vi)
mss = msssim(img_clean, img_pred)
msssim_list.append(mss)
cnt += 1
print('Mean Our UQI ' + str(np.mean(uqi_list)))
print('Mean Our MSE ' + str(np.mean(mse_list)))
print('Mean Our VIF ' + str(np.mean(vif_list)))
print('Mean Our MSSSIM ' + str(np.mean(msssim_list)))
print(str(cnt) + '\n')
# msssim_list=[]
# mse_list=[]
# tv_list=[]
