def test_invariant_denoise_color(dtype):
denoised_img_color = _invariant_denoise(
noisy_img_color.astype(dtype),
_denoise_wavelet,
denoiser_kwargs=dict(channel_axis=-1))
denoised_mse = mse(denoised_img_color, test_img_color)
original_mse = mse(noisy_img_color, test_img_color)
assert denoised_mse < original_mse
assert denoised_img_color.dtype == _supported_float_type(dtype)
def test_invariant_denoise_color():
denoised_img_color = _invariant_denoise(
noisy_img_color,
_denoise_wavelet,
denoiser_kwargs=dict(multichannel=True))
denoised_mse = mse(denoised_img_color, test_img_color)
original_mse = mse(noisy_img_color, test_img_color)
assert_(denoised_mse < original_mse)
def test_calibrate_denoiser():
parameter_ranges = {'sigma': np.linspace(0.1, 1, 5) / 2}
denoiser = calibrate_denoiser(noisy_img,
_denoise_wavelet,
denoise_parameters=parameter_ranges)
denoised_mse = mse(denoiser(noisy_img), test_img)
original_mse = mse(noisy_img, test_img)
assert_(denoised_mse < original_mse)
def test_invariant_denoise_color_deprecated():
with expected_warnings(["`multichannel` is a deprecated argument"]):
denoised_img_color = _invariant_denoise(
noisy_img_color,
_denoise_wavelet,
denoiser_kwargs=dict(multichannel=True))
denoised_mse = mse(denoised_img_color, test_img_color)
original_mse = mse(noisy_img_color, test_img_color)
assert_(denoised_mse < original_mse)
def dist_metric(A, B, mode):
if mode == 'mean_squared_error':
d = mse(A, B)
elif mode == 'adapted_rand_error':
d, _, _ = arerr(A, B)
elif mode == 'structural_similarity':
d = 1.0 - ssim(A, B)
return d
def subtract(args):
template_paths = glob.glob(args.template_dir + '/*')
template_imgs = []
for path in template_paths:
template_img = cv.imread(path)
template_imgs.append(template_img)
base_img = cv.imread(args.base_img_path)
target_img = cv.imread(args.target_img_path)
base_w, base_h = data.get_wh(base_img)
target_w, target_h = data.get_wh(target_img)
max_w, max_h = max(base_w, target_w), max(base_h, target_h)
base_img_frame = ImgFrame(base_img, (2 * max_w, 2 * max_h))
target_img_frame = ImgFrame(target_img, (2 * max_w, 2 * max_h))
offsets = get_offset(template_imgs, base_img_frame.img,
target_img_frame.img)
print(f"offset: {offsets}")
base_move = [offset if offset > 0 else 0 for offset in offsets]
target_move = [-offset if offset <= 0 else 0 for offset in offsets]
base_img_frame.move_img(*base_move)
target_img_frame.move_img(*target_move)
# Fit two images by rotation
lowest_error = math.inf
best_angle = 0
max_angle = 30
step = 2
# TODO: change to Parallel Processing.
for angle in range(-max_angle, max_angle + 1, step):
if angle == -max_angle:
base_img_frame.rotate_image(-max_angle)
else:
base_img_frame.rotate_image(step)
error = mse(base_img_frame.img_frame, target_img_frame.img_frame)
if error < lowest_error:
lowest_error = error
best_angle = angle
print(f"lowest:error is {lowest_error} in {best_angle} degree.")
# return to best angle
base_img_frame.rotate_image(best_angle - max_angle)
threshold = 50
sub_img_frame = (np.abs(target_img_frame.img_frame -
base_img_frame.img_frame) > threshold) * 255
# inter_mask_frame = base_img_frame.img_frame * target_img_frame.img_frame > 0
# sub_img_frame = sub_img_frame * inter_mask_frame
# cv.imwrite("base_img.bmp", base_img_frame.img_frame.astype(np.float32))
# cv.imwrite("target_img.bmp", target_img_frame.img_frame.astype(np.float32))
cv.imwrite(args.sub_path, sub_img_frame.astype(np.float32))
def compare_image(metric, ref, target):
if metric == 'ssim':
return ssim(ref, target, multichannel=True)
if metric == 'psnr':
return psnr(ref, target)
if metric == 'mse':
return mse(ref, target)
return None
def extract_features(ctx):
logging.debug(f"Dataset: {dataset}")
logging.debug(f"Debug: {debug}")
logging.debug(f"Epochs: {epochs}")
logging.debug(f"Batch Size: {batch_size}")
logging.debug(f"Maximum batches per epoch: {max_batches}")
logging.debug(f"Test-train split: {split*100}%")
logging.debug(f"Base features: {n_base_features}")
logging.debug(f"Latent features: {n_latent_features}")
logging.debug(f"VAE Layers: {n_layers}")
# TODO: define experiment name, make exp dir under predictions dir
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data = HCSData.from_csv(dataset) # Load dataset
test_loader = torch.utils.data.DataLoader( # Generate a testing loader
data,
batch_size=batch_size,
shuffle=False)
net = VAE_fm(lf=n_latent_features,
base=n_base_features) # TODO: load from .pt
logging.debug(net)
if torch.cuda.device_count() > 1: # If multiple gpu's
net = torch.nn.DataParallel(net) # Parallelize
net.to(device) # Move model to devic
try:
for epoch in range(epochs): # Iterate through epochs
with torch.no_grad():
for bn, (X, _) in tqdm(enumerate(test_loader),
total=max_batches):
x = X.to(device)
o, u, logvar = net(x)
X = x.cpu().detach().numpy()
O = o.cpu().detach.numpy()
err = mse(X, O)
tqdm.write(err) # TODO: Format nicely
# TODO: save feature maps (u, o) and predictions to exp dir
except (KeyboardInterrupt, SystemExit):
print("Session interrupted.")
def compare_image(metric, ref, image):
error = None
if metric == 'ssim':
error = ssim(image, ref, multichannel=True)
if metric == 'mse':
error = mse(image, ref)
if metric == 'rmse':
error = rmse(image, ref)
if metric == 'nrmse':
error = nrmse(image, ref)
return error
def test_calibrate_denoiser_extra_output():
parameter_ranges = {'sigma': np.linspace(0.1, 1, 5) / 2}
_, (parameters_tested,
losses) = calibrate_denoiser(noisy_img,
_denoise_wavelet,
denoise_parameters=parameter_ranges,
extra_output=True)
all_denoised = [
_invariant_denoise(noisy_img,
_denoise_wavelet,
denoiser_kwargs=denoiser_kwargs)
for denoiser_kwargs in parameters_tested
]
ground_truth_losses = [mse(img, test_img) for img in all_denoised]
assert_(np.argmin(losses) == np.argmin(ground_truth_losses))
def run(self):
"""
Method to execute when the thread has started
"""
for (i, (pathA, imageA)) in enumerate(self.batch):
for (y, (pathB, imageB)) in enumerate(images):
# Skip the same images, those will always be equal
if pathA == pathB:
continue
# Skip if one of them has already been removed
if pathA in removed or pathB in removed:
continue
# Remove an image if its too blurry or too similar
if blur(imageA) < blur_threshold:
remove(pathA)
elif blur(imageB) < blur_threshold:
remove(pathB)
if mse(imageA, imageB) < similarity_threshold:
remove(pathB)
def compare_full(self, img: Image, rect_color: RGBColor = (0, 0, 255), line_thickness=1, line_type=cv.LINE_8):
cim1, cim2 = self.with_color_space('BGR'), img.with_color_space('BGR')
gim1, gim2 = cim1.with_color_space('GRAY'), cim2.with_color_space('GRAY')
score, diff = gim1.compare_ssim(gim2, full=True)
diff = (diff * 255).astype("uint8")
threshold = cv.threshold(diff, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU)[1]
contours = im.grab_contours(cv.findContours(threshold.copy(), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE))
for contour in contours:
x, y, w, h = cv.boundingRect(contour)
cv.rectangle(cim1.array, (x, y), (x + w, y + h), rect_color, line_thickness, line_type)
cv.rectangle(cim2.array, (x, y), (x + w, y + h), rect_color, line_thickness, line_type)
mse_ = mse(gim1.array, gim2.array)
return {
"mse": mse_,
"ssim": score,
"image1": cim1,
"image2": cim2,
"diff": diff,
"threshold": threshold
}
def test_invariant_denoise():
denoised_img = _invariant_denoise(noisy_img, _denoise_wavelet)
denoised_mse = mse(denoised_img, test_img)
original_mse = mse(noisy_img, test_img)
assert_(denoised_mse < original_mse)
def main():
parser = argparse.ArgumentParser(
description=
"Compare multiple image using metric on different estimators")
parser.add_argument('--json',
type=str,
help="json with all build figure data",
required=True)
args = parser.parse_args()
p_json = args.json
# extract data from json configuration
json_data = None
with open(p_json, 'r') as json_file:
json_data = json.load(json_file)
reference = json_data["reference"]
estimators = json_data["estimators"]
metric = json_data["metric"]
p_folder = os.path.join(json_data['output'], json_data['nsamples'],
'processing')
p_output = os.path.join(json_data['output'], json_data['nsamples'],
'metrics')
print(f"Comparisons of {reference} with {estimators}")
if not os.path.exists(p_output):
os.makedirs(p_output)
counter = 0
for i, est in enumerate(estimators):
# get current expected method for estimator
method = json_data['methods'][i]
default_estimator_path = os.path.join(p_folder, method, reference)
# expected images path have same name
images = os.listdir(default_estimator_path)
# prepare output filename
counter_str = str(counter)
while len(counter_str) < 3:
counter_str = "0" + counter_str
output_filename = os.path.join(
p_output, f"{counter_str}_{method}_{reference}_{est}_{metric}.csv")
output_file = open(output_filename, 'w')
for img in sorted(images):
est1_path_image = os.path.join(p_folder, method, reference, img)
est2_path_image = os.path.join(p_folder, method, est, img)
img_rgb_1 = np.array(Image.open(est1_path_image))
img_rgb_2 = np.array(Image.open(est2_path_image))
scene_name = img.replace('.png', '')
if metric == 'ssim':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est,
ssim(img_rgb_1, img_rgb_2, multichannel=True))
output_file.write(sentence)
if metric == 'rmse':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est, rmse(img_rgb_1, img_rgb_2))
output_file.write(sentence)
if metric == 'nrmse':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est, nrmse(img_rgb_1, img_rgb_2))
output_file.write(sentence)
if metric == 'mse':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est, mse(img_rgb_1, img_rgb_2))
output_file.write(sentence)
if metric == 'psnr':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est, psnr(img_rgb_1, img_rgb_2))
output_file.write(sentence)
if metric == 'rmse_ssim':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est,
rmse(img_rgb_1, img_rgb_2) /
ssim(img_rgb_1, img_rgb_2, multichannel=True))
output_file.write(sentence)
if metric == 'firefly':
sentence = "{0};{1};{2};{3}\n".format(
scene_name, img, est, firefly_error(img_rgb_1, img_rgb_2))
output_file.write(sentence)
counter += 1
output_file.close()
def reconstructionAttack(model,
alpha=5000,
beta=100,
gamma=0.01,
delta=0.1,
save=True,
show=False):
dae = False
if (model.name == 'DAESoftMax'):
dae = True
# reload model
model.load_state_dict(torch.load('models/' + model.name + '_model.pt'))
# performance measures
startTime = time.time()
timeStr = time.strftime("%H:%M:%S", time.localtime(startTime))
mse_all, nrmsev_all, ssmv_all, epochs = [], [], [], []
# SDG
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=delta)
test_x = get_orig()
rec_x = np.zeros((40, 112, 92), dtype='float32')
process = False
print('DAE Flag is', dae)
# if DAE images have different size and process is true
encoder = Autoencoder(0)
if (dae):
test_x = encoder.encode(torch.Tensor(test_x))
rec_x = np.zeros((40, 300), dtype='float32')
for c in classes:
print('\nReconstructing class', c)
best_x, best_cost = '', 1
if (dae):
img = np.zeros_like(test_x[0].detach().numpy())
else:
img = np.zeros_like(test_x[0])
ssmv, msev, nrmsev = 0, 0, 0
rec, orig = '', ''
if (dae):
process = True
best_x = img = np.zeros((1, 300), dtype='float32')
else:
np.zeros_like(test_x[0])
b = beta
for i in range(alpha):
best_cost, best_x, b, img, stop = invert(model,
img,
criterion,
optimizer,
delta,
c_to_i(c),
best_cost,
best_x,
i,
b,
beta,
gamma,
processing=process)
if stop:
epochs.append(i)
break
if (dae):
orig = test_x[c_to_i(c)].detach().numpy()
rec = best_x.reshape(300)
rec_x[c_to_i(c)] = rec
else:
orig = test_x[c_to_i(c)]
rec = best_x.reshape(112, 92)
rec_x[c_to_i(c)] = rec
ssmv = ssm(rec, orig)
msev = mse(rec, orig)
nrmsev = nrmse(rec, orig)
mse_all.append(msev)
nrmsev_all.append(nrmsev)
ssmv_all.append(ssmv)
if (show or save):
if (dae):
rec = encoder.decode(torch.Tensor([rec])).view(
112, 92).detach().numpy()
orig = encoder.decode(torch.Tensor([orig])).view(
112, 92).detach().numpy()
fig = plt.figure(figsize=(10, 4))
fig.suptitle("SSM: {:.1e}, NRMSE: {:.1f}".format(ssmv, nrmsev))
ax1 = fig.add_subplot(1, 2, 1)
ax1.imshow(rec, cmap='gray')
ax2 = fig.add_subplot(1, 2, 2)
ax2.imshow(orig, cmap='gray')
plt.savefig(f'./data/results/' + model.name + '_class_' + c +
'.png')
if show:
plt.show()
endTime = time.time()
dur = endTime - startTime
print("Duration in sec: " + str(int(dur)))
# Calculating means performance values of all images
print("\nAverage performance", model.name)
print('MSE mean', np.mean(mse_all), 'with std of ', np.std(mse_all))
print('NRMSE mean', np.mean(nrmsev_all), 'with std of +/-',
np.std(nrmsev_all))
print('SSM mean', np.mean(ssmv_all), 'with std of +/-', np.std(ssmv_all))
print('Epochs mean', np.mean(epochs), 'with std of +/-', np.std(epochs))
def get_mse(y_real, y_pred, is_prepare=True):
if is_prepare:
y_pred, y_real = prepare_data(y_pred, y_real)
return mse(y_pred, y_real)
def compute_mse(
img1, img2
): # auxiliary function, computes the MSE distance between images "img1" and "img2"
return (mse(img1, img2))
def train(name, csv_file, data_path, debug, epochs, batch_size, max_batches,
split, parallel, n_base_features, n_latent_features, n_layers, beta):
# If debug, set logger level and log parameters
if debug:
logging.getLogger().setLevel(logging.DEBUG)
logging.debug(f"CSV File: {csv_file}")
logging.debug(f"Data Path: {data_path}")
logging.debug(f"Debug: {debug}")
logging.debug(f"Epochs: {epochs}")
logging.debug(f"Batch Size: {batch_size}")
logging.debug(f"Maximum batches per epoch: {max_batches}")
logging.debug(f"Test-train split: {split*100}%")
logging.debug(f"Base features: {n_base_features}")
logging.debug(f"Latent features: {n_latent_features}")
logging.debug(f"VAE Layers: {n_layers}")
# Set up gpu/cpu device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# Dataset
data = HCSData.from_csv(csv_file, data_path) # Load dataset
logging.debug('Data loaded')
train, test = data.split(split) # Split data into train and test
# data[0][0].shape
train_loader = torch.utils.data.DataLoader( # Generate a training loader
train, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader( # Generate a testing loader
test, batch_size=batch_size, shuffle=True)
net = VAE_fm(lf=n_latent_features, base=n_base_features)
logging.debug(net)
# Move Model to GPU
if torch.cuda.device_count() > 1: # If multiple gpu's
net = torch.nn.DataParallel(net) # Parallelize
net.to(device) # Move model to device
tr_writer = SummaryWriter(
f"{data_path}/runs/training_{time.strftime('%Y-%m-%d')}_{name}")
vl_writer = SummaryWriter(
f"{data_path}/runs/validation_{time.strftime('%Y-%m-%d')}_{name}")
# Define loss and optimizer
# criterion = torch.nn.MSELoss()
vae_loss = Loss()
optimizer = torch.optim.Adam(net.parameters(), lr=0.001, weight_decay=0.01)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer)
print("Training...")
try:
# Training
for epoch in range(epochs): # Iter through epochcs
cum_loss = 0
msg = f"Training epoch {epoch+1}: "
ttl = max_batches or len(train_loader) # Iter through batches
for batch_n, (X, _) in tqdm(enumerate(train_loader), msg, ttl):
if batch_n > max_batches:
break
x = X.to(device) # Move batch samples to gpu
o, u, logvar = net(x) # Forward pass
optimizer.zero_grad() # Reset gradients
loss = vae_loss(o, x, u, logvar, beta) # Compute Loss
loss.backward() # Propagate loss, compute gradients
optimizer.step() # Update weights
cum_loss += loss.item()
in_grid = torchvision.utils.make_grid(
x.view(3 * batch_size, 1, x.shape[-2], x.shape[-1]),
nrow=3
)
out_grid = torchvision.utils.make_grid(
o.view(3 * batch_size, 1, o.shape[-2], o.shape[-1]),
nrow=3
)
if True:
tr_writer.add_image('Input', in_grid, epoch *
max_batches + batch_n)
tr_writer.add_image('Output', out_grid, epoch *
max_batches + batch_n)
# writer.add_image('Mean', u_grid, epoch *
# max_batches + batch_n)
# writer.add_image('Logvar', logvar_grid, epoch *
# max_batches + batch_n)
tr_writer.add_scalar(
'loss',
loss,
epoch * max_batches + batch_n
)
tr_writer.add_scalar(
'mse',
mse(x.cpu().detach().numpy(), o.cpu().detach().numpy()),
epoch * max_batches + batch_n
)
with torch.no_grad():
val_loss = 0
val_mse = []
# Iter through batches
msg = f"Testing epoch {epoch+1}: "
ttl = max_batches or len(test_loader)
for batch_n, (X, _) in tqdm(enumerate(test_loader), msg, ttl):
if batch_n > 16:
break
# Move batch samples to gpu
x = X.to(device)
o, u, logvar = net(x) # Forward pass
loss = vae_loss(o, x, u, logvar)
val_loss += loss.item()
val_mse.append(mse(x.cpu().detach().numpy(),
o.cpu().detach().numpy()))
vl_writer.add_scalar(
'loss',
val_loss,
epoch * max_batches + batch_n
)
vl_writer.add_scalar(
'mse',
np.mean(val_mse),
epoch * max_batches + batch_n
)
scheduler.step(-cum_loss)
torch.save(net.state_dict(),
f"{data_path}/models/{net.__class__.__name__}"
f"_base-{n_base_features}_latent-{n_latent_features}"
f"_{time.strftime('%Y-%m-%d_%H-%M')}_{name}.pt"
)
except (KeyboardInterrupt, SystemExit):
print("Saving model...")
torch.save(net.state_dict(),
f"{data_path}/models/{net.__class__.__name__}"
f"_base-{n_base_features}_latent-{n_latent_features}"
f"_{time.strftime('%Y-%m-%d_%H-%M')}_{name}.pt"
)
print("Model saved.")
def get_rmse(y_real, y_pred, is_prepare=True):
if is_prepare:
y_pred, y_real = prepare_data(y_pred, y_real)
return np.sqrt(mse(y_pred, y_real))
sigma_range = np.arange(sigma / 2, 1.5 * sigma, 0.025)
parameters_tested = [{
'sigma': sigma,
'convert2ycbcr': True,
'wavelet': 'db2',
'multichannel': True
} for sigma in sigma_range]
denoised_invariant = [
_invariant_denoise(noisy, _denoise_wavelet, denoiser_kwargs=params)
for params in parameters_tested
]
self_supervised_loss = [mse(img, noisy) for img in denoised_invariant]
ground_truth_loss = [mse(img, image) for img in denoised_invariant]
opt_idx = np.argmin(self_supervised_loss)
plot_idx = [0, opt_idx, len(sigma_range) - 1]
get_inset = lambda x: x[25:225, 100:300]
plt.figure(figsize=(10, 12))
gs = gridspec.GridSpec(3, 3)
ax1 = plt.subplot(gs[0, :])
ax2 = plt.subplot(gs[1, :])
ax_image = [plt.subplot(gs[2, i]) for i in range(3)]
ax1.plot(sigma_range,
import argparse
import imutils
import random
import cv2
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-f", "--first", required=True, help="first input image")
ap.add_argument("-s", "--second", required=True, help="second")
args = vars(ap.parse_args())
# load the two input images
imageA = cv2.imread(args["first"])
imageB = cv2.imread(args["second"])
# convert the images to grayscale
grayA = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
grayB = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
# compute the Structural Similarity Index (SSIM) between the two
# images, ensuring that the difference image is returned
s = ssim(grayA, grayB, full=True)
m = mse(grayA, grayB)
m = 1 - (1 / m)
score = s[0] * 100 * m * random.random() * 100
s1 = 100000 * (s[0] + m - 1) + 1000 * random.random() + 11000
print("SSIM: {}".format(s[0]))
print("MSE: {}".format(m))
print(s1)
orig_image = cv2.imread(filename, cv2.IMREAD_COLOR)
if args.downsample:
orig_image = orig_image[::args.downsample, ::args.downsample]
sizes = []
mses = []
ssims = []
compression_times = []
decompression_times = []
for quality in tqdm.trange(101):
data, image, time_c, time_d = check_compression(orig_image, quality)
ssims.append(ssim(orig_image, image, multichannel=True))
sizes.append(len(data))
mses.append(mse(image, orig_image))
compression_times.append(time_c)
decompression_times.append(time_d)
size1 = len(check_lossless_compression(image, 1))
size9 = len(check_lossless_compression(image, 9))
print('PNG compression range:', size9, size1)
size = image.nbytes
fig = plt.figure(filename + ' JPEG performance')
ax = fig.add_subplot(2, 2, 1)
ax.set_title('Size ratio (blue) and Structural Similarity Index (orange)')
plt.plot(np.array(sizes) / size)
plt.axhline(size1 / size, color='red')
from skimage.metrics import structural_similarity as ssim
from skimage.metrics import mean_squared_error as mse
from PIL import Image
import numpy as np
import logging
# Create and configure logger
logging.basicConfig(format='%(asctime)s %(message)s', filemode='w')
logger = logging.getLogger()
logger.setLevel(logging.INFO)
original = np.array(Image.open("ImagenesGen/original.jpg").convert("LA"))
restaurada = np.array(Image.open("ImagenesGen/Ivan2.jpg").convert("LA"))
logger.info("------ SIMILAR A BLANCO NEGRO ------")
logger.info(" ------ SSIM ------")
ssim_recuperado = ssim(original, restaurada, multichannel=True)
porcentaje_recuperado_ssim = (ssim_recuperado) * 100
logger.info("Las imagene se parece aproximadamente en un: " +
str(porcentaje_recuperado_ssim) + "%")
logger.info(" ------ MSE ------")
mse_recuperado = mse(original, restaurada)
#porcentaje_recuperado_mse = 100 - ((100 * mse_recuperado) / mse_original)
logger.info("Se recuper aproximadamente un: " + str(mse_recuperado))
def test_invariant_denoise_3d():
denoised_img_3d = _invariant_denoise(noisy_img_3d, _denoise_wavelet)
denoised_mse = mse(denoised_img_3d, test_img_3d)
original_mse = mse(noisy_img_3d, test_img_3d)
assert_(denoised_mse < original_mse)
def compare_mse(self, img: Image):
return mse(self.with_color_space('GRAY').array, img.with_color_space('GRAY').array)
danada_bw = np.array(Image.open("imagenes/danada.jpg").convert("LA"))
restaurada_bw = np.array(Image.open("imagenes/restaurada.jpg").convert("LA"))
original_color = np.array(Image.open("imagenes/original.jpg"))
danada_color = np.array(Image.open("imagenes/danada.jpg"))
restaurada_color = np.array(Image.open("imagenes/restaurada.jpg"))
logger.info("------ SIMILAR A BLANCO NEGRO ------")
logger.info(" ------ SSIM ------")
ssim_original_bw = ssim(original_bw, danada_bw, multichannel=True)
ssim_recuperado_bw = ssim(original_bw, restaurada_bw, multichannel=True)
porcentaje_recuperado_bw_ssim = (ssim_recuperado_bw - ssim_original_bw) * 100
logger.info("Se recupero aproximadamente un: " + str(porcentaje_recuperado_bw_ssim) + "%")
logger.info(" ------ MSE ------")
mse_original_bw = mse(original_bw, danada_bw)
mse_recuperado_bw = mse(original_bw, restaurada_bw)
porcentaje_recuperado_bw_mse = 100 - ((100 * mse_recuperado_bw) / mse_original_bw)
logger.info("Se recupero aproximadamente un: " + str(porcentaje_recuperado_bw_mse) + "%")
logger.info("------ SIMILAR A COLOR ------")
logger.info(" ------ SSIM ------")
ssim_original_color = ssim(original_color, danada_color, multichannel=True)
ssim_recuperado_color = ssim(original_color, restaurada_color, multichannel=True)
porcentaje_recuperado_bw_ssim = (ssim_recuperado_color - ssim_original_color) * 100
logger.info("Se recupero aproximadamente un: " + str(porcentaje_recuperado_bw_ssim) + "%")
logger.info(" ------ MSE ------")
mse_original_color = mse(original_color, danada_color)
mse_recuperado_color = mse(original_color, restaurada_color)
porcentaje_recuperado_bw_mse = 100 - ((100 * mse_recuperado_color) / mse_original_color)
def removeLoosers(self):
rangSum = (len(self.oldIndivids) + 1) / 2 * len(self.oldIndivids)
self.individs = []
bord = self.size - self.startize // 2
self.size = int(self.startize * 1.5)
maxbord = len(self.oldIndivids)
if self.oldIndivids:
for i in self.oldIndivids:
if i.rang > bord:
i.survival += 1 / ((maxbord - i.rang + 1)**2)
self.individs.append(i)
rng = self.size - len(self.individs)
halfrang = len(self.oldIndivids) / 2
if rng > 0:
metricsList = {}
for i in range(len(self.newgeneratedIndivids)):
dat1 = img_as_float(self.newgeneratedIndivids[i].img)
metricsval = 0
for j in self.oldIndivids:
dat2 = img_as_float(j.img)
countmetr = mse(dat1, dat2)
if countmetr <= 0.005:
self.newgeneratedIndivids[i].lookslike = True
metricsval += countmetr * (
(j.rang**2) / halfrang**2 - 1) / 3
if metricsval != -1:
metricsval *= -1
self.newgeneratedIndivids[i].fit = metricsval
metricsList[i] = metricsval
list_keys = sorted(metricsList, key=metricsList.get)
leftToStay = min(
rng - rng // 5, len(list_keys)
) ##### 80% элитизм, для mse оказалось лучшим решением его увеличить
for i in range(len(list_keys)):
self.newgeneratedIndivids[list_keys[i]].rang = i + 1
list_keys = list(reversed(list_keys))
for i in self.individs:
i.rang = len(self.newgeneratedIndivids) + i.rang - bord
alreadyin = []
for i in range(self.newgenarateSize):
if leftToStay > 0:
if self.newgeneratedIndivids[
list_keys[i]].fit not in alreadyin:
self.individs.append(
self.newgeneratedIndivids[list_keys[i]])
alreadyin.append(
self.newgeneratedIndivids[list_keys[i]].fit)
leftToStay -= 1
else:
break
newindlen = len(self.newgeneratedIndivids)
allPie = (newindlen + 1) / 2 * newindlen - (
2 * newindlen - leftToStay + 1) / 2 * leftToStay
leftToStay = min(self.size - len(self.individs), len(list_keys))
while leftToStay > 0:
piePart = randint(1, allPie)
countPieParts = 0
for i in self.newgeneratedIndivids:
if (i not in self.individs) and (i.fit not in alreadyin):
countPieParts += i.rang
if piePart <= countPieParts:
self.individs.append(i)
allPie -= i.rang
leftToStay -= 1
alreadyin.append(i.fit)
break
rangList = {}
countSimilar = 0
for i in range(len(self.individs)):
rangList[self.individs[i].rang] = i
if self.individs[i].lookslike:
countSimilar += 1
self.individs[i].lookslike = False
datcheck1 = img_as_float(self.individs[i].img)
for j in range(len(self.individs)):
datcheck2 = img_as_float(self.individs[j].img)
countmetrch = mse(datcheck1, datcheck2)
if countmetrch != 0 and countmetrch <= 0.011:
self.individs[i].lookslike = True
break
if countSimilar >= len(self.individs) * 2 / 3:
self.cont = True
else:
self.cont = False
countSimilar = 0
for i in self.individs:
if i.lookslike:
countSimilar += 1
if countSimilar >= len(self.individs) / 2:
self.cont = True
list_keys = list(rangList.keys())
list_keys.sort()
for i in range(len(list_keys)):
self.individs[rangList[list_keys[i]]].rang = i + 1
self.oldIndivids = self.individs
temp_points = random.choices(range(pts1.shape[0]), k=3)
a = pts1[temp_points]
b = pts2[temp_points]
M = cv.getAffineTransform(b, a)
image_path = target_images_two[i]
target_image = cv.imread(image_path)
converted = cv.warpAffine(target_image, M, (image.shape[0], image.shape[1]))
mse_value = ssim(main_images, converted, multichannel=True)
if mse_value > best_value:
best = converted
best_value = mse_value
k += 1
temp_mse = mse(main_images, best)
temp_ssim = ssim(main_images, best, multichannel=True)
all_mse.append(temp_mse)
all_ssim.append(temp_ssim)
print("MSE = ", temp_mse)
print("SSIM = ", temp_ssim)
cv.imwrite("../output/converted_Attack_2_{}.jpg".format(i + 1), best)
all_mp = np.array(all_mp)
all_mse = np.array(all_mse)
all_ssim = np.array(all_ssim)
print("mean MP = ", all_mp.mean())
print("mean MSE = ", all_mse.mean())
print("mean SSIM = ", all_ssim.mean())
print("std MP = ", all_mp.std())
print("std MSE = ", all_mse.std())
def main(dataset_name=None):
cuda = True if torch.cuda.is_available() else False
IMAGE_SIZE = np.array([256, 256])
opt.dataset_name = dataset_name
files = opt.dataroot + opt.dataset_name + '_' + opt.phase + '.txt'
comp_paths = []
harmonized_paths = []
mask_paths = []
real_paths = []
with open(files, 'r') as f:
for line in f.readlines():
name_str = line.rstrip()
if opt.evaluation_type == 'our':
harmonized_path = os.path.join(
opt.result_root, name_str.replace(".jpg",
"_harmonized.jpg"))
if os.path.exists(harmonized_path):
real_path = os.path.join(
opt.result_root, name_str.replace(".jpg", "_real.jpg"))
mask_path = os.path.join(
opt.result_root, name_str.replace(".jpg", "_mask.jpg"))
comp_path = os.path.join(
opt.result_root, name_str.replace(".jpg", "_comp.jpg"))
elif opt.evaluation_type == 'ori':
comp_path = os.path.join(opt.dataroot, 'composite_images',
line.rstrip())
harmonized_path = comp_path
if os.path.exists(comp_path):
real_path = os.path.join(opt.dataroot, 'real_images',
line.rstrip())
name_parts = real_path.split('_')
real_path = real_path.replace(
('_' + name_parts[-2] + '_' + name_parts[-1]), '.jpg')
mask_path = os.path.join(opt.dataroot, 'masks',
line.rstrip())
mask_path = mask_path.replace(('_' + name_parts[-1]),
'.png')
real_paths.append(real_path)
mask_paths.append(mask_path)
comp_paths.append(comp_path)
harmonized_paths.append(harmonized_path)
count = 0
mse_scores = 0
sk_mse_scores = 0
fmse_scores = 0
psnr_scores = 0
fpsnr_scores = 0
ssim_scores = 0
fssim_scores = 0
fore_area_count = 0
fmse_score_list = []
image_size = 256
for i, harmonized_path in enumerate(tqdm(harmonized_paths)):
count += 1
harmonized = Image.open(harmonized_path).convert('RGB')
real = Image.open(real_paths[i]).convert('RGB')
mask = Image.open(mask_paths[i]).convert('1')
if mask.size[0] != image_size:
harmonized = tf.resize(harmonized, [image_size, image_size],
interpolation=Image.BICUBIC)
mask = tf.resize(mask, [image_size, image_size],
interpolation=Image.BICUBIC)
real = tf.resize(real, [image_size, image_size],
interpolation=Image.BICUBIC)
harmonized_np = np.array(harmonized, dtype=np.float32)
real_np = np.array(real, dtype=np.float32)
harmonized = tf.to_tensor(harmonized_np).unsqueeze(0).cuda()
real = tf.to_tensor(real_np).unsqueeze(0).cuda()
mask = tf.to_tensor(mask).unsqueeze(0).cuda()
mse_score = mse(harmonized_np, real_np)
psnr_score = psnr(real_np, harmonized_np, data_range=255)
fore_area = torch.sum(mask)
fmse_score = torch.nn.functional.mse_loss(
harmonized * mask, real * mask) * 256 * 256 / fore_area
mse_score = mse_score.item()
fmse_score = fmse_score.item()
fore_area_count += fore_area.item()
fpsnr_score = 10 * np.log10((255**2) / fmse_score)
ssim_score, fssim_score = pytorch_ssim.ssim(
harmonized, real, window_size=opt.ssim_window_size, mask=mask)
psnr_scores += psnr_score
mse_scores += mse_score
fmse_scores += fmse_score
fpsnr_scores += fpsnr_score
ssim_scores += ssim_score
fssim_scores += fssim_score
image_name = harmonized_path.split("/")
image_fmse_info = (image_name[-1], round(fmse_score, 2),
fore_area.item(), round(mse_score, 2),
round(psnr_score, 2), round(fpsnr_scores, 4))
fmse_score_list.append(image_fmse_info)
mse_scores_mu = mse_scores / count
psnr_scores_mu = psnr_scores / count
fmse_scores_mu = fmse_scores / count
fpsnr_scores_mu = fpsnr_scores / count
ssim_scores_mu = ssim_scores / count
fssim_score_mu = fssim_scores / count
print(count)
mean_sore = "%s MSE %0.2f | PSNR %0.2f | SSIM %0.4f |fMSE %0.2f | fPSNR %0.2f | fSSIM %0.4f" % (
opt.dataset_name, mse_scores_mu, psnr_scores_mu, ssim_scores_mu,
fmse_scores_mu, fpsnr_scores_mu, fssim_score_mu)
print(mean_sore)
return mse_scores_mu, fmse_scores_mu, psnr_scores_mu, fpsnr_scores_mu
