def compare_images(self, im1, im2, imageA, imageB):
# compute the mean squared error and structural similarity
# index for the images
m = self.mse(imageA, imageB)
s = ssim(imageA, imageB)
tres = args['threshold']
self.totalCompare += 1
if s >= tres:
print("Image[{c1}] '{p1}' compared to Image[{c2}] '{p2}' Simility:{sim}".format(c1=im1['comp'], c2=im2['comp'],p1=im1['path'], p2=im2['path'], sim=str(s)))
twin = np.hstack([imageA, imageB])
cv2.imshow('', twin)
cv2.waitKey(0)
self.searching = False
self.totalFound += 1
companyTotal = self.companyResults.get(img)
elif self.searching is False:
print('Searching...')
self.searching = True
def crop(self, img):
max_ssim = 0
bbox = None
resized = np.asarray(img.resize((192, 108)))
height = img.height
width = img.width
for idx, ref in enumerate(self.references):
cur_ssim = ssim(ref, resized, multichannel=True)
if cur_ssim > max_ssim:
max_ssim = cur_ssim
bbox = self.reference_bboxes[idx]
pil_bbox = [
np.round(bbox[0] * width),
np.round(bbox[1] * height),
np.round(bbox[2] * width),
np.round(bbox[3] * height)
]
return img.crop(bbox)
def compare_images(imageA, imageB, title):
# compute the mean squared error and structural similarity
# index for the images
m = mse(imageA, imageB)
s = ssim(imageA, imageB)
# setup the figure
fig = plt.figure(title)
plt.suptitle("MSE: %.2f, SSIM: %.2f" % (m, s))
# show first image
ax = fig.add_subplot(1, 2, 1)
plt.imshow(imageA, cmap = plt.cm.gray)
plt.axis("off")
# show the second image
ax = fig.add_subplot(1, 2, 2)
plt.imshow(imageB, cmap = plt.cm.gray)
plt.axis("off")
# show the images
plt.show()
def compare_images(path1, path2, imageA, imageB):
# compute the mean squared error and structural similarity
# index for the images
m = mse(imageA, imageB)
s = ssim(imageA, imageB)
tres = args['threshold']
searchingWritten = False
if s >= tres:
print("Image '{0}' comparet to '{1}' Simility:'{2}".format(
[path1, path2, str(m), str(tres),
str(s)]))
twin = np.hstack([imageA, imageB])
cv2.imshow('', twin)
cv2.waitKey(0)
elif searchingWritten is not True:
print('Searching...')
searchingWritten = True
def showtime(imageRef, imageMod, imageModRGB):
(score, diff) = ssim(imageRef, imageMod, full=True)
diff = (diff * 255).astype("uint8")
# st.sidebar.text("SSIM: {}".format(score))
thresh = cv2.threshold(diff, 0, 255,
cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
contador = 0
for c in cnts:
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(imageModRGB, (x, y), (x + w, y + h), (255, 0, 0), 2)
print(cv2.boundingRect(c))
contador = contador + 1
print(contador)
return contador, score, imageModRGB
def get_ssim(image_labels, attacked_image_labels):
"""
Given an unattacked and an attacked ImageLabels objects, calculate the SSIM score between them
Args:
image_labels: the ImageLabels object for the unattacked image
attacked_imaged_labels: the ImageLabels object for the attacked image
Returns:
ssim_val: the SSIM value calculated between the two images
"""
img = io.imread(image_labels.img_path)
attack_img = io.imread(attacked_image_labels.img_path)
ssim_val = ssim(
img,
attack_img,
data_range = attack_img.max() - attack_img.min(),
multichannel=True)
return ssim_val
def main():
argparser = argparse.ArgumentParser()
argparser.add_argument('--image_dir', type=str, required=True)
argparser.add_argument('--image_list_file', type=str, required=True)
argparser.add_argument('--ssim_matrix_file', type=str, required=True)
argparser.add_argument('--mse_matrix_file', type=str, required=True)
argparser.add_argument('--image_symlink_dir', type=str, required=True)
args = argparser.parse_args()
image_dir = Path(args.image_dir)
images = []
for image in image_dir.glob('**/*'):
if image.is_dir():
continue
images.append(image)
# Save image list so we can identify images later
images.sort()
image_list_file = open(args.image_list_file, 'w')
zfill_len = len(str(len(images)))
for i in range(len(images)):
image_list_file.write(f'{i}, {images[i]}\n')
symlink_dir = Path(args.image_symlink_dir) / Path(
str(i).zfill(zfill_len))
symlink_dir.mkdir(exist_ok=True, parents=True)
symlink_target = Path('../' * len(symlink_dir.parts)) / images[i]
(symlink_dir / images[i].name).symlink_to(symlink_target)
image_list_file.close()
ssim_matrix_file = open(args.ssim_matrix_file, 'w')
mse_matrix_file = open(args.mse_matrix_file, 'w')
for i in range(len(images)):
i_img = np.array(Image.open(images[i]))
for j in range(i + 1, len(images)):
j_img = np.array(Image.open(images[j]))
ssim_matrix_file.write(
str(ssim(i_img, j_img, multichannel=True)) + ',')
mse_matrix_file.write(str(mean_squared_error(i_img, j_img)) + ',')
ssim_matrix_file.write('\n')
mse_matrix_file.write('\n')
ssim_matrix_file.close()
mse_matrix_file.close()
def test_single(net, img, target, image_name, model_name, test_image):
net.eval()
tens = transforms.ToTensor()
h, w, c = img.shape
inp = tens(img).float()
inp = inp.view((1, c, h, w))
output = net(inp)
o = output.view((c, h * 4, w * 4))
o = o.data.numpy()
o = np.swapaxes(o, 0, 1)
o = np.swapaxes(o, 1, 2)
bicub_res = rescale(img, (4, 4, 1), anti_aliasing=True)
result = np.clip(o + bicub_res, 0., 1.)
result = np.clip(correct_color_shift(target, result, samples=100), 0., 1.)
if result.shape != target.shape:
w1, h1, c1 = result.shape
w2, h2, c2 = target.shape
if w1 < w2:
target = target[0:w1, :, :]
elif w1 > w2:
result = result[0:w2, :, :]
if h1 < h2:
target = target[:, 0:h1, :]
elif h1 > h2:
result = result[:, 0:h2, :]
# PSNR
score = psnr(result, target) * 1.10326
sim = ssim(result, target, multichannel=True)
if image_name == test_image:
fig, ax1 = plt.subplots(1, 1)
ax1.imshow(result)
ax1.set_title(model_name)
plt.show()
#plt.imsave('results_reconstr/{m}/{n}'.format(m=os.path.splitext(model_name)[0], n=image_name), result)
"""if model_name == 'ENet-E.pth':
io.imsave('quality_assessment/E/{x}'.format(x=image_name), result)
elif model_name == 'ENet-PAT.pth':
io.imsave('quality_assessment/PAT/{x}'.format(x=image_name), result)"""
#print('Image name: %s PSNR: %f SSIM: %f' % (image_name, score, sim))
return score, sim
def test_skgpr_2d(kernel):
R = np.load(test_data)
R_ = np.load(test_expected_result)
X = gprutils.get_sparse_grid(R)
X_true = gprutils.get_full_grid(R)
mean, _ = skgpr.skreconstructor(X,
R,
X_true,
kernel=kernel,
lengthscale=[[1., 1.], [4., 4.]],
grid_points_ratio=1.,
learning_rate=0.1,
iterations=20,
calculate_sd=False,
num_batches=1,
use_gpu=False,
verbose=False).run()
assert_(ssim(mean, R_) > 0.98)
assert_(np.linalg.norm(mean - R_) < 1)
def compute_similarity(self, im, im_deg, sim_method='mutual_info'):
im = np.array(im)
im_deg = np.array(im_deg)
if sim_method == 'mutual_info':
return mutual_information(im, im_deg)
elif sim_method == 'dice':
return f1_score(
im.astype(bool).ravel(),
im_deg.astype(bool).ravel())
elif sim_method == 'ssim':
return ssim(im.astype(bool), im_deg.astype(bool))
elif sim_method == 'var_info':
under_seg, over_seg = variation_of_information(
im.astype(bool), im_deg.astype(bool))
return 1 - (under_seg + over_seg)
elif sim_method == 'mse':
return 1 - mean_squared_error(
im.astype(bool).ravel(),
im_deg.astype(bool).ravel())
def bjorn_score(image1: np.ndarray, image2: np.ndarray) -> float:
"""Calculates the Bjorn score of two input images.
0 = Two images are perfectly similar
<0.1 = Two images are structurally similar
1 = Two images are not similar
Arguments:
image1 {np.ndarray} -- Image 1
image2 {np.ndarray} -- Image 2
Returns:
float -- bjorn score of image1 and image2
"""
if image1.shape != image2.shape:
# Images not matching
return 1.0
score = 1.0 - ssim(image1, image2, multichannel=True)
return score
def compute_test_ssim(test_dataset, model):
ssim_val = []
model.eval()
device = (torch.device("cuda:0")
if torch.cuda.is_available() else torch.device("cpu"))
model.to(device)
for image, target in test_dataset:
pred = model(wrap_input(image).to(device))
pred = unwrap_output(pred[0])
target = unwrap_output(target)
ssim_val.append(
ssim(
target,
pred,
data_range=pred.max() - pred.min(),
multichannel=True,
))
return np.array(ssim_val).mean()
def SSIM(X_test, X_hat, start_time=0):
num_images, num_timesteps, _, _ = X_test.shape
ssim_values = []
for idx in range(num_images):
for t in range(start_time, num_timesteps):
img_truth = X_test[idx, t, :, :]
img_hat = X_hat[idx, t, :, :]
ssim_img = ssim(img_truth,
img_hat,
data_range=img_truth.max() - img_truth.min())
if math.isnan(ssim_img):
continue
ssim_values.append(ssim_img)
ssim_model = np.mean(ssim_values)
return ssim_model, ssim_values
def check_bug4():
folder_bug = 'bug_right/'
files = os.listdir(folder_bug)
img_bug = [file for file in files if file.startswith('bug')]
img = Image.open("current_screen.png")
left = 305
top = 42
right = 320
bottom = 72
im1 = img.crop((left, top, right, bottom))
im1.save('current_test.png')
imgA = cv2.imread("current_test.png")
for elem in img_bug:
imgB = cv2.imread(folder_bug + elem)
s = ssim(imgA, imgB, multichannel=True)
if s > 0.9:
print(s)
return True
return False
def calculate_metrics(gt_img: np.ndarray,
recon_img: np.ndarray,
verbose=True) -> tuple:
"""
Display PSNR, SSIM, SNR and MSE for reconstructed image
against ground truth.
Args:
gt_img: groud truth image
recon_img: reconstructed image
verbose: wether to print the metrics or just return them
Returns:
tuple of metrics
"""
assert gt_img.shape == recon_img.shape
if isinstance(gt_img, Tensor):
gt_img = gt_img.cpu().detach().numpy()
if isinstance(recon_img, Tensor):
recon_img = recon_img.cpu().detach().numpy()
gt_img = np.array(gt_img, dtype=np.float64)
recon_img = np.array(recon_img, dtype=np.float64)
psnr = peak_signal_noise_ratio(gt_img,
recon_img,
data_range=recon_img.max() -
recon_img.min())
img_ssim = ssim(gt_img,
recon_img,
data_range=recon_img.max() - recon_img.min())
snr = calculate_snr(gt_img, recon_img)
mse = mean_squared_error(gt_img, recon_img)
if verbose:
print('============================')
print(f'PSNR: {psnr}')
print(f'SSIM: {img_ssim}')
print(f'SNR: {snr}')
print(f'MSE: {mse}')
print('============================')
return psnr, img_ssim, snr, mse
def minl(lam, signal):
print('lambda = ', lam)
print('\n')
#cargamos los datos
timev, noise = np.loadtxt('noise.dat',
delimiter=' ',
usecols=(0, 1),
unpack=True)
freq, asd = np.loadtxt('ruido_psd.dat',
delimiter=' ',
usecols=(0, 1),
unpack=True)
psd = asd**2
s = np.load('datagood.npy')
ORIGINAL = s[signal]
#elegimos un segundo de tiempo del vector noise
index = int(len(noise) / 2)
RUIDO = noise[0 + index:index + int(len(noise) / 2)]
#escalamos la señal a la SNR correspondiente
SNR = 8
ESCALADA = set_snr(ORIGINAL, psd, SNR, freq, 16384, 1)[1]
SUMA = ESCALADA + RUIDO
SUMA = norm(SUMA)
#ejecutamos el código ROF
#gs1(f, h, beta, lam, tol)
DENOISED = gs1(SUMA, 1, .01, lam, .001)
ORIGINAL_MOD = gs1(ESCALADA, 1, .01, lam, .001)
lower = 3700
upper = 4600
ppplot(norm(SUMA), norm(ORIGINAL_MOD), norm(DENOISED))
np.save('DENOISED', DENOISED)
np.save('SUMA', SUMA)
np.save('ORIGINAL', ORIGINAL_MOD)
#return(mse(norm(DENOISED)[lower:upper], norm(ORIGINAL_MOD)[lower:upper]))
return (1 -
ssim(norm(DENOISED)[lower:upper],
norm(ORIGINAL_MOD)[lower:upper]))
def quality(truth, recon):
"""
ALEX NOTE: Modified it so it uses sci-kit image's psnr, and also added data_range parameters
"""
# for fixed images truth and reconstruction, evaluates average l2 value and ssim score
amount_images = truth.shape[0]
# recon = cut_image(recon)
l2 = np.average(np.sqrt(np.sum(np.square(truth - recon), axis=(1, 2, 3))))
psn = 0
for k in range(amount_images):
# psn = psn + psnr(truth[k,...,0], cut_image(recon[k,...,0]), data_range=1)
psn = psn + psnr(truth[k, ..., 0], recon[k, ..., 0], data_range=1)
psn = psn / amount_images
ssi = 0
for k in range(amount_images):
# ssi = ssi + ssim(truth[k,...,0], cut_image(recon[k,...,0]), data_range=1)
ssi = ssi + ssim(truth[k, ..., 0], recon[k, ..., 0], data_range=1)
ssi = ssi / amount_images
return [l2, psn, ssi]
def evaluate(args):
path_in = args.data_dir_in
path_tar = args.data_dir_tar
file_in = sorted(os.listdir(path_in))
file_tar = sorted(os.listdir(path_tar))
len_list_in = len(file_in)
# calculate PSNR, SSIM
psnr_avg = 0
ssim_avg = 0
ssim_avg_self = 0
# SSIM_func = SSIM().cuda()
for i in range(len_list_in):
list_in = os.path.join(path_in, file_in[i])
# list_tar = os.path.join(path_tar, file_tar[i//15])
list_tar = os.path.join(path_tar, file_tar[i])
img_in = cv2.imread(list_in)
img_tar = cv2.imread(list_tar)
mse = ((img_in - img_tar)**2).mean()
# psnr_tmp = 10 * log10(255 * 255 / (mse + 10 ** (-10)))
# psnr_avg += psnr_tmp
psnr_tmp = psnr(img_in, img_tar, data_range=255)
psnr_avg += psnr_tmp
ssim_tmp = ssim(img_in, img_tar, data_range=255, multichannel=True)
ssim_avg += ssim_tmp
# img_in_torch, img_tar_torch = RGB_np2tensor(img_in, img_tar)
# c, h, w = img_in_torch.shape
# img_in_torch = torch.reshape(img_in_torch, (1, c, h, w))
# img_tar_torch = torch.reshape(img_tar_torch, (1, c, h, w))
# ssim_tmp_self = SSIM_func(img_in_torch, img_tar_torch)
# ssim_avg_self += ssim_tmp_self
print('%s: PSNR = %2.5f, SSIM = %2.5f' %
(file_in[i], psnr_tmp, ssim_tmp))
psnr_avg = psnr_avg / len_list_in
ssim_avg = ssim_avg / len_list_in
# ssim_avg_self = ssim_avg_self / len_list_in
print('avg psnr = %2.5f, avg SSIM = %1.5f' % (psnr_avg, ssim_avg))
def parse_video(images, video, frames_jump_comparison, verbose=False):
#iterate through video frames
#similarities = [{'frame': 0, 'similarity': 0}]
count = 0
#get current time
fps_time = time.clock()
cap = cv2.VideoCapture(video)
total_frame = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
highlights_frame_number = []
while (cap.isOpened()):
ret, frame = cap.read()
#break at EOF
if (type(frame) == type(None)):
break
#increment frame counter
print(count)
print(total_frame)
count += 1
#resize current video frame
small_frame = cv2.resize(frame, (10, 10))
#convert to greyscale
small_frame_bw = color.rgb2gray(small_frame)
similarity = []
#compare current frame to source image
for i in range(len(images)):
similarity.append(ssim(images[i], small_frame_bw))
if (similarity[i] > 0.95):
highlights_frame_number.append(count)
cap.release()
return highlights_frame_number
def get_metrics(data_folder_1, data_folder_2, metric):
metric_vals = []
for i in tqdm(range(10000)):
file_name = str(i) + ".png"
file_path_1 = os.path.join(data_folder_1, file_name)
file_path_2 = os.path.join(data_folder_2, file_name)
image1 = np.array(Image.open(file_path_1).convert('RGB')) / 255.
image2 = (np.array(Image.open(file_path_2).convert('RGB')) /
255.)[:, :, :3]
if metric == "ssim":
metric_vals.append(ssim(image1, image2, multichannel=True))
elif metric == "psnr":
metric_vals.append(psnr(image1, image2))
elif metric == "mse":
metric_vals.append(1 - mse(image1, image2))
return metric_vals
def print_score(ref_img, res_img):
"""
Compute SSIM score on two images and print a result.
:param ref_img: reference image
:param res_img: result image
"""
# score = jaccard_score(ref_img.flatten(), res_img.flatten(), average='macro')
ref_img_float = img_as_float(ImageProcess.to_gray(ref_img))
res_img_float = img_as_float(ImageProcess.to_gray(res_img))
score = ssim(ref_img_float,
res_img_float,
data_range=res_img_float.max() - res_img_float.min(),
gaussian_weights=True)
print("-------------------------")
print(
"SSIM: ",
round(score, 2),
)
print("-------------------------")
def struc_sim(target, img): ''' Calculate structure similarity between 2 images. ------------------------------------------------- param: target: numpy array image in "RGB" param: img: numpy array image in "RGB" ''' # target image original size. target_dim = (target.shape[1], target.shape[0]) # if target original size > 500, downsize the image if target_dim[0] > 1000 or target_dim[1] > 1000: target_dim = tuple([int(d*0.25) for d in target_dim]) # Downsize target image to be smaller target = cv2.resize(target, target_dim, interpolation=cv2.INTER_AREA) # resize img to match target size img = cv2.resize(img, target_dim, interpolation=cv2.INTER_AREA) # convert target image to gray scale target_gray = cv2.cvtColor(target, cv2.COLOR_RGB2GRAY) img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) return ssim(target_gray, img_gray)
def checkSsim(cap: PILImg, tpl: PILImg, loc):
box = (int(loc[0] * tpl.size[0]), int(loc[1] * tpl.size[1]),
int(loc[2] * tpl.size[0]), int(loc[3] * tpl.size[1]))
size = tpl.size
cap = cap.resize(size).crop(box).convert("L")
tpl = tpl.resize(size).crop(box).convert("L")
# for very small window
size = tpl.size
while size[0] < 20 or size[1] < 20:
size = (size[0] * 2, size[1] * 2)
cap = cap.resize(size)
tpl = tpl.resize(size)
# cap.show()
# tpl.show()
likeness = ssim(pil_plugin.pil_to_ndarray(cap),
pil_plugin.pil_to_ndarray(tpl))
return likeness
def to_ssim_skimage(dehaze, gt):
dehaze_list = torch.split(dehaze, 1, dim=0)
gt_list = torch.split(gt, 1, dim=0)
dehaze_list_np = [
dehaze_list[ind].permute(0, 2, 3, 1).data.cpu().numpy().squeeze()
for ind in range(len(dehaze_list))
]
gt_list_np = [
gt_list[ind].permute(0, 2, 3, 1).data.cpu().numpy().squeeze()
for ind in range(len(dehaze_list))
]
ssim_list = [
ssim(dehaze_list_np[ind],
gt_list_np[ind],
data_range=1,
multichannel=True) for ind in range(len(dehaze_list))
]
return ssim_list
def SSIM(tensor1, tensor2, zoom=False):
ssim_list = []
for slice_idx in [50, 80, 110, 140]:
if zoom:
side_a = slice_idx
side_b = slice_idx + 60
img1, img2 = tensor1[side_a:side_b, side_a:side_b,
105], tensor2[side_a:side_b, side_a:side_b,
105]
else:
img1, img2 = tensor1[slice_idx, :, :], tensor2[slice_idx, :, :]
img1 = img_as_float(img1)
img2 = img_as_float(img2)
ssim_val = ssim(img1, img2)
if ssim_val != ssim_val:
print('\n\n Error @ SSIM')
sys.exit()
ssim_list.append(ssim_val)
ssim_avg = sum(ssim_list) / len(ssim_list)
return ssim_avg
def compare_images(img1, img2, SSIM_FACTOR=0.8):
from skimage.metrics import structural_similarity as ssim
import cv2 # opencv-python
# load the images -- the original, the original + contrast,
# and the original + photoshop
imageA = cv2.imread(img1)
image_A = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
imageB = cv2.imread(img2)
image_B = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
### Structural Similarity Measure
s = ssim(image_A, image_B)
print("SSIM(x,y) = " + str(s))
if s > SSIM_FACTOR:
return True
else:
return False
def compute_ssim_rmse():
""" Compute RMSE and SSIM for images in given dir """
# results_dir = '../../enlighten_gan/EnlightenGAN/ablation/enlightengan_retrain/test_latest/images'
true_img_dir = '../datasets/lol/eval15/high'
# results_dir = '/raid/pkmandke/projects/cv_project/results/ex3tr5_bilinear_rmse/400/images'
results_dir = './results/clahe/lol/eval15'
f = open('./results/clahe_final.txt', 'w')
ssim_sum, rmse_sum = 0., 0.
for file in os.listdir(results_dir):
# if file.endswith('.png') and 'fake_B' in file:
if True:
true = file
# true = file.split('.')[0].split('_')[1] + '.png'
# true = file.split('_')[0] + '.png'
pred = cv2.cvtColor(cv2.imread(os.path.join(results_dir, file)),
cv2.COLOR_BGR2RGB)
high = cv2.cvtColor(cv2.imread(os.path.join(true_img_dir, true)),
cv2.COLOR_BGR2RGB)
normed = lambda x: (x - x.min()) / (x.max() - x.min())
pred = normed(pred)
high = normed(high)
cur_rmse = mean_squared_error(pred, high)
cur_ssim = ssim(pred,
high,
data_range=high.max() - high.min(),
multichannel=True,
win_size=11)
ssim_sum += cur_ssim
rmse_sum += cur_rmse
f.write("Image: {}, SSIM = {}, RMSE = {}\n".format(
true, cur_ssim, cur_rmse))
f.write("Mean SSIM = {}, Mean RMSE = {}\n".format(
ssim_sum / len(os.listdir(true_img_dir)),
rmse_sum / len(os.listdir(true_img_dir))))
f.close()
def write_gs_summary(slm_field, recon_field, target_amp, k, writer, roi=(880, 1600), prefix='test'):
"""tensorboard summary for GS"""
slm_phase = slm_field.angle()
recon_amp, recon_phase = recon_field.abs(), recon_field.angle()
loss = nn.MSELoss().to(recon_amp.device)
recon_amp = crop_image(recon_amp, target_shape=roi, stacked_complex=False)
target_amp = crop_image(target_amp, target_shape=roi, stacked_complex=False)
recon_amp *= (torch.sum(recon_amp * target_amp, (-2, -1), keepdim=True)
/ torch.sum(recon_amp * recon_amp, (-2, -1), keepdim=True))
loss_value = loss(recon_amp, target_amp)
psnr_value = psnr(target_amp.squeeze().cpu().detach().numpy(), recon_amp.squeeze().cpu().detach().numpy())
ssim_value = ssim(target_amp.squeeze().cpu().detach().numpy(), recon_amp.squeeze().cpu().detach().numpy())
if writer is not None:
writer.add_image(f'{prefix}_Recon/amp', recon_amp.squeeze(0), k)
writer.add_scalar(f'{prefix}_loss', loss_value, k)
writer.add_scalar(f'{prefix}_psnr', psnr_value, k)
writer.add_scalar(f'{prefix}_ssim', ssim_value, k)
def FrameSimilarity(frames_jpg_path):
# calculates the "structured similarity index" between adjacent frames
# ssim() looks at luminance, contrast and structure, it is a scikit-image function
# we use ssim() for both (1) Shot Change detection, and (2) Action weight
files = [f for f in os.listdir(frames_jpg_path) if isfile(join(frames_jpg_path,f))]
files.sort()
# initialize array
ssi_array = []
# number of adjacent frames
numadj = len(files)-2
# loop through all adjacent frames and calculate the ssi
for i in range (0, numadj):
# for i in range (0, 4000):
frame_a = cv2.imread(frames_jpg_path+'frame'+str(i)+'.jpg')
frame_b = cv2.imread(frames_jpg_path+'frame'+str(i+1)+'.jpg')
frame_a_bw = cv2.cvtColor(frame_a, cv2.COLOR_BGR2GRAY)
frame_b_bw = cv2.cvtColor(frame_b, cv2.COLOR_BGR2GRAY)
ssim_ab = ssim(frame_a_bw, frame_b_bw)
ssim_ab = round(ssim_ab, 3)
ssi_array.append(ssim_ab)
return (ssi_array)
def compute_mse_ssim_scores(self):
for img_type in self.image_types:
images = os.listdir(self.model_path)
mse_arr = []
ssim_arr = []
# mse_info = []
for img_name in images:
if img_type in img_name:
orig_img = img_as_float(rgb2gray(io.imread(os.path.join(self.gt_path, img_name))))
mask_img = img_as_float(rgb2gray(io.imread(os.path.join(self.model_path, img_name))))
mse_mask = mean_squared_error(orig_img, mask_img)
ssim_mask = ssim(orig_img, mask_img, multichannel=True, gaussian_weights=True, sigma=1.5, use_sample_covariance=False, data_range=255)
mse_arr.append(mse_mask)
ssim_arr.append(ssim_mask)
# mse_info.append({'image_name': img_name, 'image_type':img_type, 'mse': mse_mask, 'ssim': ssim_mask})
# self.write_list_to_csv(mse_info, mse_info[0].keys(),
# filename='inference_info_' + img_type + '_' + self.model_name + '.csv')
self.mse_avg[img_type], self.mse_std[img_type] = np.mean(mse_arr), np.std(mse_arr)
self.ssim_avg[img_type], self.ssim_std[img_type] = np.mean(ssim_arr), np.std(ssim_arr)
