def _get_mscn_variance(block, sub_block_size=(50, 50)):
blocks = segmentation.divide_in_blocks(block, sub_block_size)
data = []
for block in blocks:
mscn_coefficients = transform.get_mscn_coefficients(block)
flat_coeff = mscn_coefficients.flatten()
data.append(np.var(flat_coeff))
return np.sort(data)
def main():
parser = argparse.ArgumentParser(
description=
"Classify zones using complexity criteria (unsupervised learning)")
parser.add_argument('--data',
type=str,
help='required data file',
required=True)
parser.add_argument('--clusters',
type=int,
help='number of expected clusters',
default=2)
parser.add_argument('--output',
type=str,
help='output folder name',
required=True)
args = parser.parse_args()
p_data = args.data
p_clusters = args.clusters
p_output = args.output
x_values = []
images_path = []
images = []
zones = []
scenes = []
with open(p_data, 'r') as f:
for line in f.readlines():
data = line.split(';')
del data[-1]
scene = data[0]
if scene not in scenes:
scenes.append(scene)
images_path.append(data[1])
zones.append(int(data[2]))
img_arr = segmentation.divide_in_blocks(Image.open(data[1]),
(200, 200))[int(data[2])]
images.append(np.array(img_arr))
x = []
for v in data[3:]:
x.append(float(v))
x_values.append(x)
print(scenes)
# plt.show()
# TODO : save kmean model
kmeans = KMeans(init='k-means++', n_clusters=p_clusters, n_init=10)
labels = kmeans.fit(x_values).labels_
unique, counts = np.unique(labels, return_counts=True)
print(dict(zip(unique, counts)))
pca = PCA(n_components=2)
x_data = pca.fit_transform(x_values)
# Need to create as global variable so our callback(on_plot_hover) can access
fig, ax = plt.subplots()
fig.set_figheight(20)
fig.set_figwidth(40)
ax.tick_params(axis='both', which='major', labelsize=20)
sc = plt.scatter(x_data[:, 0], x_data[:, 1], c=labels, linewidths=10)
# annot = ax.annotate("", xy=(0,0), xytext=(20,20), textcoords="offset points",
# bbox=dict(boxstyle="round", fc="w"),
# arrowprops=dict(arrowstyle="->"))
imagebox = OffsetImage(images[0], zoom=1.2)
imagebox.image.axes = ax
annot = AnnotationBbox(imagebox,
xy=(0, 0),
xybox=(-150., 150.),
xycoords='data',
boxcoords="offset points",
pad=0.8,
arrowprops=dict(arrowstyle="->"))
annot.set_visible(False)
ax.add_artist(annot)
def update_annot(ind):
imagebox = OffsetImage([images[n] for n in ind["ind"]][0], zoom=1.2)
imagebox.image.axes = ax
pos = sc.get_offsets()[ind["ind"][0]]
setattr(annot, 'offsetbox', imagebox)
annot.xy = pos
# text = "{}, {}".format(" ".join(list(map(str,ind["ind"]))),
# " ".join([images_path[n] for n in ind["ind"]]))
# annot.text(text)
# #annot.get_bbox_patch().set_facecolor(cmap(norm(c[ind["ind"][0]])))
# annot.get_bbox_patch().set_alpha(0.4)
def hover(event):
vis = annot.get_visible()
if event.inaxes == ax:
cont, ind = sc.contains(event)
if cont:
update_annot(ind)
annot.set_visible(True)
fig.canvas.draw_idle()
else:
if vis:
annot.set_visible(False)
fig.canvas.draw_idle()
fig.canvas.mpl_connect("motion_notify_event", hover)
#plt.show()
if not os.path.exists(model_output_folder):
os.makedirs(model_output_folder)
model_path = os.path.join(model_output_folder, p_output + '.joblib')
print('Model saved into {0}'.format(model_path))
joblib.dump(kmeans, model_path)
def display_data_scenes(data_type, p_scene, p_kind):
"""
@brief Method which displays data from scene
@param data_type, feature choice
@param scene, scene choice
@param mode, normalization choice
@return nothing
"""
scenes = os.listdir(path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# go ahead each scenes
for folder_scene in scenes:
if p_scene == folder_scene:
print(folder_scene)
scene_path = os.path.join(path, folder_scene)
# construct each zones folder name
zones_folder = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone" + index_str
zones_folder.append(current_zone)
zones_images_data = []
threshold_info = []
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
start_image_path = scene_images[0]
end_image_path = scene_images[-1]
start_quality_image = dt.get_scene_image_quality(scene_images[0])
end_quality_image = dt.get_scene_image_quality(scene_images[-1])
for id_zone, zone_folder in enumerate(zones_folder):
zone_path = os.path.join(scene_path, zone_folder)
# get threshold information
path_seuil = os.path.join(zone_path, seuil_expe_filename)
# open treshold path and get this information
with open(path_seuil, "r") as seuil_file:
threshold_learned = int(seuil_file.readline().strip())
threshold_image_found = False
for img_path in scene_images:
current_quality_image = dt.get_scene_image_quality(
img_path)
if threshold_learned < int(current_quality_image
) and not threshold_image_found:
threshold_image_found = True
threshold_image_path = img_path
threshold_image = dt.get_scene_image_postfix(img_path)
threshold_info.append(threshold_image)
# all indexes of picture to plot
images_path = [
start_image_path, threshold_image_path, end_image_path
]
images_data = []
for img_path in images_path:
current_img = Image.open(img_path)
img_blocks = segmentation.divide_in_blocks(
current_img, (200, 200))
# getting expected block id
block = img_blocks[id_zone]
data = get_image_features(data_type, block)
##################
# Data mode part #
##################
# modify data depending mode
if p_kind == 'svdn':
data = utils.normalize_arr(data)
if p_kind == 'svdne':
path_min_max = os.path.join(
path, data_type + min_max_filename)
with open(path_min_max, 'r') as f:
min_val = float(f.readline())
max_val = float(f.readline())
data = utils.normalize_arr_with_range(
data, min_val, max_val)
# append of data
images_data.append(data)
zones_images_data.append(images_data)
fig = plt.figure(figsize=(8, 8))
fig.suptitle(data_type + " values for " + p_scene +
" scene (normalization : " + p_kind + ")",
fontsize=20)
for id, data in enumerate(zones_images_data):
fig.add_subplot(4, 4, (id + 1))
plt.plot(data[0], label='Noisy_' + start_quality_image)
plt.plot(data[1], label='Threshold_' + threshold_info[id])
plt.plot(data[2], label='Reference_' + end_quality_image)
plt.ylabel(data_type + ' SVD, ZONE_' + str(id + 1),
fontsize=18)
plt.xlabel('Vector features', fontsize=18)
plt.legend(bbox_to_anchor=(0.5, 1),
loc=2,
borderaxespad=0.2,
fontsize=18)
plt.ylim(0, 0.1)
plt.show()
def main():
parser = argparse.ArgumentParser(description="Read and compute entropy data file")
parser.add_argument('--model', type=str, help='model file')
parser.add_argument('--method', type=str, help='method name to used', choices=cfg.features_choices_labels, default=cfg.features_choices_labels[0])
parser.add_argument('--interval', type=str, help='Interval value to keep from svd', default='"0, 200"')
parser.add_argument('--kind', type=str, help='Kind of normalization level wished', choices=cfg.normalization_choices)
parser.add_argument('--imnorm', type=int, help="specify if image is normalized before computing something", default=0, choices=[0, 1])
parser.add_argument('--scene', type=str, help='Scene index to use', choices=cfg.scenes_indices)
parser.add_argument('--save', type=str, help='filename where to save input data')
parser.add_argument('--label', type=str, help='label to use when saving thresholds')
args = parser.parse_args()
p_model = args.model
p_method = args.method
p_interval = list(map(int, args.interval.split(',')))
#p_n_stop = args.n_stop
p_imnorm = args.imnorm
p_scene = args.scene
p_mode = args.kind
p_save = args.save
p_label = args.label
p_n_stop = 1
begin, end = p_interval
# 1. get scene name
scenes_list = cfg.scenes_names
scenes_indices = cfg.scenes_indices
scene_index = scenes_indices.index(p_scene.strip())
scene = scenes_list[scene_index]
scene_path = os.path.join(cfg.dataset_path, scene)
# 2. load model and compile it
# TODO : check kind of model
model = joblib.load(p_model)
# model.compile(loss='binary_crossentropy',
# optimizer='rmsprop',
# metrics=['accuracy'])
estimated_thresholds = []
n_estimated_thresholds = []
human_thresholds = []
# 3. retrieve human_thresholds
# construct zones folder
zones_list = []
for index in zones_indices:
index_str = str(index)
while len(index_str) < 2:
index_str = "0" + index_str
zones_list.append(cfg.zone_folder + index_str)
for zone in zones_list:
zone_path = os.path.join(scene_path, zone)
with open(os.path.join(zone_path, cfg.seuil_expe_filename), 'r') as f:
human_thresholds.append(int(f.readline()))
# 4. get estimated thresholds using model and specific method
images_path = sorted([os.path.join(scene_path, img) for img in os.listdir(scene_path) if cfg.scene_image_extension in img])
number_of_images = len(images_path)
image_indices = [ dt.get_scene_image_quality(img_path) for img_path in images_path ]
image_counter = 0
print(human_thresholds)
# append empty list
for zone in zones_list:
estimated_thresholds.append(None)
n_estimated_thresholds.append(0)
for img_i, img_path in enumerate(images_path):
blocks = segmentation.divide_in_blocks(Image.open(img_path), (200, 200))
for index, block in enumerate(blocks):
if estimated_thresholds[index] is None:
# normalize if necessary
if p_imnorm:
block = np.array(block) / 255.
# check if prediction is possible
data = np.array(get_image_features(p_method, np.array(block)))
if p_mode == 'svdn':
data = utils.normalize_arr_with_range(data)
data = data[begin:end]
#data = np.expand_dims(data, axis=0)
#print(data.shape)
prob = model.predict(np.array(data).reshape(1, -1))[0]
#print(index, ':', image_indices[img_i], '=>', prob)
if prob < 0.5:
n_estimated_thresholds[index] += 1
# if same number of detection is attempted
if n_estimated_thresholds[index] >= p_n_stop:
estimated_thresholds[index] = image_indices[img_i]
else:
n_estimated_thresholds[index] = 0
# write progress bar
write_progress((image_counter + 1) / number_of_images)
image_counter = image_counter + 1
# default label
for i, _ in enumerate(zones_list):
if estimated_thresholds[i] == None:
estimated_thresholds[i] = image_indices[-1]
# 6. save estimated thresholds into specific file
print(estimated_thresholds)
print(p_save)
if p_save is not None:
with open(p_save, 'a') as f:
f.write(p_label + ';')
for t in estimated_thresholds:
f.write(str(t) + ';')
f.write('\n')
def main():
parser = argparse.ArgumentParser(
description="Read and compute entropy data file")
parser.add_argument('--model', type=str, help='model .h5 file')
parser.add_argument('--folder',
type=str,
help='folder where scene dataset is available',
required=True)
parser.add_argument(
'--features',
type=str,
help="list of features choice in order to compute data",
default='svd_reconstruction, ipca_reconstruction',
required=True)
parser.add_argument(
'--params',
type=str,
help=
"list of specific param for each feature choice (See README.md for further information in 3D mode)",
default='100, 200 :: 50, 25',
required=True)
parser.add_argument('--size',
type=str,
help="specific size of image",
default='100, 100',
required=True)
parser.add_argument('--n_stop',
type=int,
help='number of detection to make sure to stop',
default=1)
parser.add_argument('--save',
type=str,
help='filename where to save input data')
parser.add_argument('--label',
type=str,
help='label to use when saving thresholds')
args = parser.parse_args()
p_model = args.model
p_folder = args.folder
p_features = list(map(str.strip, args.features.split(',')))
p_params = list(map(str.strip, args.params.split('::')))
p_size = args.size
p_n_stop = args.n_stop
p_save = args.save
p_label = args.label
# 1. Load expected transformations
# list of transformations
transformations = []
for id, feature in enumerate(p_features):
if feature not in cfg.features_choices_labels or feature == 'static':
raise ValueError(
"Unknown feature, please select a correct feature (`static` excluded) : ",
cfg.features_choices_labels)
transformations.append(Transformation(feature, p_params[id], p_size))
# 2. load model and compile it
# TODO : check kind of model
model = load_model(p_model)
# model.compile(loss='binary_crossentropy',
# optimizer='rmsprop',
# metrics=['accuracy'])
estimated_thresholds = []
n_estimated_thresholds = []
scene_path = p_folder
if not os.path.exists(scene_path):
print('Unvalid scene path:', scene_path)
exit(0)
# 3. retrieve human_thresholds
# construct zones folder
zones_indices = np.arange(16)
zones_list = []
for index in zones_indices:
index_str = str(index)
while len(index_str) < 2:
index_str = "0" + index_str
zones_list.append(cfg.zone_folder + index_str)
# 4. get estimated thresholds using model and specific method
images_path = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
number_of_images = len(images_path)
image_indices = [
dt.get_scene_image_quality(img_path) for img_path in images_path
]
image_counter = 0
# append empty list
for _ in zones_list:
estimated_thresholds.append(None)
n_estimated_thresholds.append(0)
for img_i, img_path in enumerate(images_path):
blocks = segmentation.divide_in_blocks(Image.open(img_path),
(200, 200))
for index, block in enumerate(blocks):
if estimated_thresholds[index] is None:
transformed_list = []
# compute data here
for transformation in transformations:
transformed = transformation.getTransformedImage(block)
transformed_list.append(transformed)
data = np.array(transformed_list)
# compute input size
n_chanels, _, _ = data.shape
if K.image_data_format() == 'chanels_first':
if n_chanels > 1:
data = np.expand_dims(data, axis=0)
else:
if n_chanels > 1:
data = data.transpose()
data = np.expand_dims(data, axis=0)
else:
data = data.transpose()
data = np.expand_dims(data, axis=0)
probs = model.predict(np.array(data))[0]
prediction = list(probs).index(max(probs))
#print(index, ':', image_indices[img_i], '=>', prediction)
if prediction == 0:
n_estimated_thresholds[index] += 1
# if same number of detection is attempted
if n_estimated_thresholds[index] >= p_n_stop:
estimated_thresholds[index] = image_indices[img_i]
else:
n_estimated_thresholds[index] = 0
# write progress bar
write_progress((image_counter + 1) / number_of_images)
image_counter = image_counter + 1
# default label
for i, _ in enumerate(zones_list):
if estimated_thresholds[i] == None:
estimated_thresholds[i] = image_indices[-1]
# 6. save estimated thresholds into specific file
print('\nEstimated thresholds', estimated_thresholds)
if p_save is not None:
with open(p_save, 'a') as f:
f.write(p_label + ';')
for t in estimated_thresholds:
f.write(str(t) + ';')
f.write('\n')
def generate_data_svd(data_type, color, mode):
"""
@brief Method which generates all .csv files from scenes
@param data_type, feature choice
@param mode, normalization choice
@return nothing
"""
scenes = os.listdir(path)
# filter scene
scenes = [s for s in scenes if calibration_folder not in s]
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# keep in memory min and max data found from data_type
min_val_found = sys.maxsize
max_val_found = 0
data_min_max_filename = os.path.join(path, data_type + min_max_filename)
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
print(folder_scene)
scene_path = os.path.join(path, folder_scene)
for noise in noise_choices:
noise_path = os.path.join(scene_path, noise)
# getting output filename
if color:
output_svd_filename = data_type + "_color_" + mode + generic_output_file_svd
else:
output_svd_filename = data_type + "_" + mode + generic_output_file_svd
# construct each zones folder name
zones_folder = []
svd_output_files = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone"+index_str
zones_folder.append(current_zone)
zone_path = os.path.join(noise_path, current_zone)
if not os.path.exists(zone_path):
os.makedirs(zone_path)
svd_file_path = os.path.join(zone_path, output_svd_filename)
# add writer into list
svd_output_files.append(open(svd_file_path, 'w'))
counter_index = 1
while(counter_index < end_counter_index):
if counter_index % picture_step == 0:
counter_index_str = str(counter_index)
if color:
img_path = os.path.join(noise_path, folder_scene + "_" + noise + "_color_" + counter_index_str + ".png")
else:
img_path = os.path.join(noise_path, folder_scene + "_" + noise + "_" + counter_index_str + ".png")
current_img = Image.open(img_path)
img_blocks = divide_in_blocks(current_img, (200, 200))
for id_block, block in enumerate(img_blocks):
###########################
# feature computation part #
###########################
data = get_image_features(data_type, block)
##################
# Data mode part #
##################
# modify data depending mode
if mode == 'svdne':
# getting max and min information from min_max_filename
with open(data_min_max_filename, 'r') as f:
min_val = float(f.readline())
max_val = float(f.readline())
data = utils.normalize_arr_with_range(data, min_val, max_val)
if mode == 'svdn':
data = utils.normalize_arr(data)
# save min and max found from dataset in order to normalize data using whole data known
if mode == 'svd':
current_min = data.min()
current_max = data.max()
if current_min < min_val_found:
min_val_found = current_min
if current_max > max_val_found:
max_val_found = current_max
# now write data into current writer
current_file = svd_output_files[id_block]
# add of index
current_file.write(counter_index_str + ';')
for val in data:
current_file.write(str(val) + ";")
current_file.write('\n')
if color:
print(data_type + "_" + noise + "_color_" + mode + "_" + folder_scene + " - " + "{0:.2f}".format((counter_index) / (end_counter_index)* 100.) + "%")
else:
print(data_type + "_" + noise + "_"+ mode + "_" + folder_scene + " - " + "{0:.2f}".format((counter_index) / (end_counter_index)* 100.) + "%")
sys.stdout.write("\033[F")
counter_index += 1
for f in svd_output_files:
f.close()
if color:
print(data_type + "_" + noise + "_color_" + mode + "_" + folder_scene + " - " + "Done...")
else:
print(data_type + "_" + noise + "_"+ mode + "_" + folder_scene + " - " + "Done...")
# save current information about min file found
if mode == 'svd':
with open(data_min_max_filename, 'w') as f:
f.write(str(min_val_found) + '\n')
f.write(str(max_val_found) + '\n')
print("%s : end of data generation\n" % mode)
def display_data_scenes(p_scene, p_bits, p_shifted):
"""
@brief Method which generates all .csv files from scenes photos
@param p_scene, scene we want to show values
@param nb_bits, number of bits expected
@param p_shifted, number of bits expected to be shifted
@return nothing
"""
scenes = os.listdir(path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# go ahead each scenes
for folder_scene in scenes:
if p_scene == folder_scene:
print(folder_scene)
scene_path = os.path.join(path, folder_scene)
# construct each zones folder name
zones_folder = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone" + index_str
zones_folder.append(current_zone)
zones_images_data = []
threshold_info = []
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
start_image_path = scene_images[0]
end_image_path = scene_images[-1]
start_quality_image = dt.get_scene_image_quality(scene_images[0])
end_quality_image = dt.get_scene_image_quality(scene_images[-1])
for id_zone, zone_folder in enumerate(zones_folder):
zone_path = os.path.join(scene_path, zone_folder)
# get threshold information
path_seuil = os.path.join(zone_path, seuil_expe_filename)
# open treshold path and get this information
with open(path_seuil, "r") as seuil_file:
threshold_learned = int(seuil_file.readline().strip())
threshold_image_found = False
# for each images
for img_path in scene_images:
current_quality_image = dt.get_scene_image_quality(
img_path)
if threshold_learned < int(current_quality_image
) and not threshold_image_found:
threshold_image_found = True
threshold_image_path = img_path
threshold_image = dt.get_scene_image_postfix(img_path)
threshold_info.append(threshold_image)
# all indexes of picture to plot
images_path = [
start_image_path, threshold_image_path, end_image_path
]
images_data = []
for img_path in images_path:
current_img = Image.open(img_path)
img_blocks = segmentation.divide_in_blocks(
current_img, (200, 200))
# getting expected block id
block = img_blocks[id_zone]
# get data from mode
# Here you can add the way you compute data
low_bits_block = transform.rgb_to_LAB_L_bits(
block, (p_shifted + 1, p_shifted + p_bits + 1))
data = compression.get_SVD_s(low_bits_block)
##################
# Data mode part #
##################
# modify data depending mode
data = utils.normalize_arr(data)
images_data.append(data)
zones_images_data.append(images_data)
fig = plt.figure(figsize=(8, 8))
fig.suptitle('Lab SVD ' + str(p_bits) + ' bits shifted by ' +
str(p_shifted) + " for " + p_scene + " scene",
fontsize=20)
for id, data in enumerate(zones_images_data):
fig.add_subplot(4, 4, (id + 1))
plt.plot(data[0], label='Noisy_' + start_quality_image)
plt.plot(data[1], label='Threshold_' + threshold_info[id])
plt.plot(data[2], label='Reference_' + end_quality_image)
plt.ylabel('Lab SVD ' + str(p_bits) + ' bits shifted by ' +
str(p_shifted) + ', ZONE_' + str(id + 1),
fontsize=14)
plt.xlabel('Vector features', fontsize=16)
plt.legend(bbox_to_anchor=(0.5, 1),
loc=2,
borderaxespad=0.2,
fontsize=14)
plt.ylim(0, 0.1)
plt.show()
def main():
parser = argparse.ArgumentParser(
description="Read and compute entropy data file")
parser.add_argument(
'--data',
type=str,
help='entropy file data with estimated threshold to read and compute')
parser.add_argument('--scene',
type=str,
help='Scene index to use',
choices=cfg.scenes_indices)
parser.add_argument('--metric',
type=str,
help='metric to use to compare',
choices=['ssim', 'mse', 'rmse', 'mae', 'psnr'])
parser.add_argument('--norm',
type=int,
help='normalize or not values',
choices=[0, 1],
default=0)
parser.add_argument('--info', type=str, help='title information to add')
args = parser.parse_args()
p_data = args.data
p_scene = args.scene
p_metric = args.metric
p_norm = args.norm
p_info = args.info
# check fr_iqa metric
try:
fr_iqa = getattr(fr, p_metric)
except AttributeError:
raise NotImplementedError("FR IQA `{}` not implement `{}`".format(
fr.__name__, p_metric))
scenes_list = cfg.scenes_names
scenes_indices = cfg.scenes_indices
scene_index = scenes_indices.index(p_scene.strip())
scene = scenes_list[scene_index]
displayed_data = {}
steps_zones = []
scene_found = False
reference_zones = None
# read line by line file to estimate threshold entropy stopping criteria
with open(p_data, 'r') as f:
lines = f.readlines()
for line in lines:
data = line.split(';')
scene_name = data[0]
zone_index = int(data[1])
steps = data[4].split(',')
if scene_name == scene:
if not scene_found:
scene_folder = os.path.join(cfg.dataset_path, scene_name)
images = sorted([
img for img in os.listdir(scene_folder)
if cfg.scene_image_extension in img
])
images_scene = [
Image.open(os.path.join(scene_folder, img))
for img in images
]
scene_found = True
# get zones of each step images
for i, _ in enumerate(steps):
steps_zones.append(
segmentation.divide_in_blocks(
images_scene[i], block_size))
# get zone of reference
reference_name = cfg.references_scenes[scene_index]
reference_path = os.path.join(cfg.references_folder,
reference_name)
reference_zones = segmentation.divide_in_blocks(
Image.open(reference_path), block_size)
# TODO : load images at each step and compare error
# store all needed data
displayed_data[zone_index] = {}
displayed_data[zone_index]['zone'] = data[2]
displayed_data[zone_index]['human_threshold'] = data[3]
displayed_data[zone_index]['steps'] = list(map(int, steps))
displayed_data[zone_index]['data'] = list(
map(float, data[5].split(',')))
errors = []
previous_block = None
# get errors from images zones (using step and reference)
for i, _ in enumerate(steps):
if i > 0:
noisy_block = steps_zones[i][zone_index]
step_error = fr_iqa(noisy_block, previous_block)
errors.append(step_error)
previous_block = steps_zones[i][zone_index]
displayed_data[zone_index]['errors'] = errors
display_estimated_thresholds(scene, displayed_data, p_info, p_metric,
p_norm)
def generate_data_model(_scenes_list,
_filename,
_transformations,
_scenes,
_nb_zones=4,
_random=0,
_only_noisy=0):
output_train_filename = _filename + ".train"
output_test_filename = _filename + ".test"
if not '/' in output_train_filename:
raise Exception(
"Please select filename with directory path to save data. Example : data/dataset"
)
# create path if not exists
if not os.path.exists(output_data_folder):
os.makedirs(output_data_folder)
train_file_data = []
test_file_data = []
scenes = os.listdir(dataset_path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# go ahead each scenes
for id_scene, folder_scene in enumerate(_scenes_list):
scene_path = os.path.join(dataset_path, folder_scene)
config_file_path = os.path.join(scene_path, config_filename)
# only get last image path
with open(config_file_path, "r") as config_file:
last_image_name = config_file.readline().strip()
ref_image_path = os.path.join(scene_path, last_image_name)
zones_indices = zones
# shuffle list of zones (=> randomly choose zones)
# only in random mode
if _random:
random.shuffle(zones_indices)
# store zones learned
learned_zones_indices = zones_indices[:_nb_zones]
# write into file
folder_learned_path = os.path.join(learned_folder,
_filename.split('/')[1])
if not os.path.exists(folder_learned_path):
os.makedirs(folder_learned_path)
file_learned_path = os.path.join(folder_learned_path,
folder_scene + '.csv')
with open(file_learned_path, 'w') as f:
for i in learned_zones_indices:
f.write(str(i) + ';')
ref_image_blocks = divide_in_blocks(Image.open(ref_image_path),
cfg.keras_img_size)
for id_zone, index_folder in enumerate(zones_indices):
index_str = str(index_folder)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone_folder = "zone" + index_str
zone_path = os.path.join(scene_path, current_zone_folder)
# path of zone of reference image
# ref_image_block_path = os.path.join(zone_path, last_image_name)
# compute augmented images for ref image
current_ref_zone_image = ref_image_blocks[id_zone]
ref_image_name_prefix = last_image_name.replace('.png', '')
dt.augmented_data_image(current_ref_zone_image, zone_path,
ref_image_name_prefix)
# get list of all augmented ref images
ref_augmented_images = [
os.path.join(zone_path, f) for f in os.listdir(zone_path)
if ref_image_name_prefix in f
]
# custom path for interval of reconstruction and features
features_path = []
for transformation in _transformations:
# check if it's a static content and create augmented images if necessary
if transformation.getName() == 'static':
# {sceneName}/zoneXX/static
static_features_path = os.path.join(
zone_path, transformation.getName())
# img.png
image_name = transformation.getParam().split('/')[-1]
# {sceneName}/zoneXX/static/img
image_prefix_name = image_name.replace('.png', '')
image_folder_path = os.path.join(static_features_path,
image_prefix_name)
if not os.path.exists(image_folder_path):
os.makedirs(image_folder_path)
features_path.append(image_folder_path)
# get image path to manage
# {sceneName}/static/img.png
transform_image_path = os.path.join(
scene_path, transformation.getName(), image_name)
static_transform_image = Image.open(transform_image_path)
static_transform_image_block = divide_in_blocks(
static_transform_image, cfg.keras_img_size)[id_zone]
# generate augmented data
dt.augmented_data_image(static_transform_image_block,
image_folder_path,
image_prefix_name)
else:
features_interval_path = os.path.join(
zone_path, transformation.getTransformationPath())
features_path.append(features_interval_path)
# as labels are same for each features
for label in os.listdir(features_path[0]):
if (label == cfg.not_noisy_folder
and _only_noisy == 0) or label == cfg.noisy_folder:
label_features_path = []
for path in features_path:
label_path = os.path.join(path, label)
label_features_path.append(label_path)
# getting images list for each features
features_images_list = []
for index_features, label_path in enumerate(
label_features_path):
if _transformations[index_features].getName(
) == 'static':
# by default append nothing..
features_images_list.append([])
else:
images = sorted(os.listdir(label_path))
features_images_list.append(images)
# construct each line using all images path of each
for index_image in range(0, len(features_images_list[0])):
images_path = []
# get information about rotation and flip from first transformation (need to be a not static transformation)
current_post_fix = features_images_list[0][
index_image].split(
cfg.post_image_name_separator)[-1]
# getting images with same index and hence name for each features (transformation)
for index_features in range(0, len(features_path)):
# custom behavior for static transformation (need to check specific image)
if _transformations[index_features].getName(
) == 'static':
# add static path with selecting correct data augmented image
image_name = _transformations[
index_features].getParam().split(
'/')[-1].replace('.png', '')
img_path = os.path.join(
features_path[index_features], image_name +
cfg.post_image_name_separator +
current_post_fix)
images_path.append(img_path)
else:
img_path = features_images_list[
index_features][index_image]
images_path.append(
os.path.join(
label_features_path[index_features],
img_path))
# get information about rotation and flip
current_post_fix = images_path[0].split(
cfg.post_image_name_separator)[-1]
# get ref block which matchs we same information about rotation and flip
augmented_ref_image_block_path = next(
img for img in ref_augmented_images
if img.split(cfg.post_image_name_separator)[-1] ==
current_post_fix)
line = augmented_ref_image_block_path + ';'
# compute line information with all images paths
for id_path, img_path in enumerate(images_path):
if id_path < len(images_path) - 1:
line = line + img_path + '::'
else:
line = line + img_path
line = line + '\n'
if id_zone < _nb_zones and folder_scene in _scenes:
train_file_data.append(line)
else:
test_file_data.append(line)
train_file = open(output_train_filename, 'w')
test_file = open(output_test_filename, 'w')
random.shuffle(train_file_data)
random.shuffle(test_file_data)
for line in train_file_data:
train_file.write(line)
for line in test_file_data:
test_file.write(line)
train_file.close()
test_file.close()
def main():
parser = argparse.ArgumentParser(description="Script which predicts threshold using specific keras model")
parser.add_argument('--features', type=str,
help="list of features choice in order to compute data",
default='svd_reconstruction, ipca_reconstruction',
required=True)
parser.add_argument('--params', type=str,
help="list of specific param for each metric choice (See README.md for further information in 3D mode)",
default='100, 200 :: 50, 25',
required=True)
parser.add_argument('--model', type=str, help='.json file of keras model', required=True)
parser.add_argument('--size', type=str, help="Expected output size before processing transformation", default="100,100")
parser.add_argument('--renderer', type=str,
help='Renderer choice in order to limit scenes used',
choices=cfg.renderer_choices,
default='all',
required=True)
args = parser.parse_args()
p_features = list(map(str.strip, args.features.split(',')))
p_params = list(map(str.strip, args.params.split('::')))
p_model_file = args.model
p_size = args.size
p_renderer = args.renderer
scenes_list = dt.get_renderer_scenes_names(p_renderer)
scenes = os.listdir(scenes_path)
print(scenes)
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
# only take in consideration renderer scenes
if folder_scene in scenes_list:
print(folder_scene)
scene_path = os.path.join(scenes_path, folder_scene)
# get all images of folder
scene_images = sorted([os.path.join(scene_path, img) for img in os.listdir(scene_path) if cfg.scene_image_extension in img])
number_scene_image = len(scene_images)
start_quality_image = dt.get_scene_image_quality(scene_images[0])
end_quality_image = dt.get_scene_image_quality(scene_images[-1])
# using first two images find the step of quality used
quality_step_image = dt.get_scene_image_quality(scene_images[1]) - start_quality_image
threshold_expes = []
threshold_expes_found = []
block_predictions_str = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
zone_folder = "zone"+index_str
threshold_path_file = os.path.join(os.path.join(scene_path, zone_folder), threshold_expe_filename)
with open(threshold_path_file) as f:
threshold = int(f.readline())
threshold_expes.append(threshold)
# Initialize default data to get detected model threshold found
threshold_expes_found.append(int(end_quality_image)) # by default use max
block_predictions_str.append(index_str + ";" + p_model_file + ";" + str(threshold) + ";" + str(start_quality_image) + ";" + str(quality_step_image))
# for each images
for img_path in scene_images:
current_img = Image.open(img_path)
img_blocks = divide_in_blocks(current_img, cfg.sub_image_size)
current_quality_image = dt.get_scene_image_quality(img_path)
for id_block, block in enumerate(img_blocks):
# check only if necessary for this scene (not already detected)
#if not threshold_expes_detected[id_block]:
tmp_file_path = tmp_filename.replace('__model__', p_model_file.split('/')[-1].replace('.json', '_'))
block.save(tmp_file_path)
python_cmd = "python predict_noisy_image.py --image " + tmp_file_path + \
" --features " + p_features + \
" --params " + p_params + \
" --model " + p_model_file + \
" --size " + p_size
## call command ##
p = subprocess.Popen(python_cmd, stdout=subprocess.PIPE, shell=True)
(output, err) = p.communicate()
## Wait for result ##
p_status = p.wait()
prediction = int(output)
# save here in specific file of block all the predictions done
block_predictions_str[id_block] = block_predictions_str[id_block] + ";" + str(prediction)
print(str(id_block) + " : " + str(current_quality_image) + "/" + str(threshold_expes[id_block]) + " => " + str(prediction))
print("------------------------")
print("Scene " + str(id_scene + 1) + "/" + str(len(scenes)))
print("------------------------")
# end of scene => display of results
# construct path using model name for saving threshold map folder
model_threshold_path = os.path.join(threshold_map_folder, p_model_file.split('/')[-1].replace('.joblib', ''))
# create threshold model path if necessary
if not os.path.exists(model_threshold_path):
os.makedirs(model_threshold_path)
map_filename = os.path.join(model_threshold_path, simulation_curves_zones + folder_scene)
f_map = open(map_filename, 'w')
for line in block_predictions_str:
f_map.write(line + '\n')
f_map.close()
print("Scene " + str(id_scene + 1) + "/" + str(len(maxwell_scenes)) + " Done..")
print("------------------------")
print("Model predictions are saved into %s" % map_filename)
def generate_data_model(_filename, _transformations, _dataset_folder, _selected_zones):
output_train_filename = os.path.join(output_data_folder, _filename, _filename + ".train")
output_test_filename = os.path.join(output_data_folder, _filename, _filename + ".test")
# create path if not exists
if not os.path.exists(os.path.join(output_data_folder, _filename)):
os.makedirs(os.path.join(output_data_folder, _filename))
train_file_data = []
test_file_data = []
# specific number of zones (zones indices)
zones = np.arange(16)
# go ahead each scenes
for folder_scene in _selected_zones:
scene_path = os.path.join(_dataset_folder, folder_scene)
train_zones = _selected_zones[folder_scene]
for id_zone, index_folder in enumerate(zones):
index_str = str(index_folder)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone_folder = "zone" + index_str
zone_path = os.path.join(scene_path, current_zone_folder)
# custom path for interval of reconstruction and metric
features_path = []
for transformation in _transformations:
# check if it's a static content and create augmented images if necessary
if transformation.getName() == 'static':
# {sceneName}/zoneXX/static
static_metric_path = os.path.join(zone_path, transformation.getName())
# img.png
image_name = transformation.getParam().split('/')[-1]
# {sceneName}/zoneXX/static/img
image_prefix_name = image_name.replace('.png', '')
image_folder_path = os.path.join(static_metric_path, image_prefix_name)
if not os.path.exists(image_folder_path):
os.makedirs(image_folder_path)
features_path.append(image_folder_path)
# get image path to manage
# {sceneName}/static/img.png
transform_image_path = os.path.join(scene_path, transformation.getName(), image_name)
static_transform_image = Image.open(transform_image_path)
static_transform_image_block = divide_in_blocks(static_transform_image, cfg.sub_image_size)[id_zone]
dt.augmented_data_image(static_transform_image_block, image_folder_path, image_prefix_name)
else:
metric_interval_path = os.path.join(zone_path, transformation.getTransformationPath())
features_path.append(metric_interval_path)
# as labels are same for each metric
for label in os.listdir(features_path[0]):
label_features_path = []
for path in features_path:
label_path = os.path.join(path, label)
label_features_path.append(label_path)
# getting images list for each metric
features_images_list = []
for index_metric, label_path in enumerate(label_features_path):
if _transformations[index_metric].getName() == 'static':
# by default append nothing..
features_images_list.append([])
else:
images = sorted(os.listdir(label_path))
features_images_list.append(images)
# construct each line using all images path of each
for index_image in range(0, len(features_images_list[0])):
images_path = []
# get information about rotation and flip from first transformation (need to be a not static transformation)
current_post_fix = features_images_list[0][index_image].split(cfg.post_image_name_separator)[-1]
# getting images with same index and hence name for each metric (transformation)
for index_metric in range(0, len(features_path)):
# custom behavior for static transformation (need to check specific image)
if _transformations[index_metric].getName() == 'static':
# add static path with selecting correct data augmented image
image_name = _transformations[index_metric].getParam().split('/')[-1].replace('.png', '')
img_path = os.path.join(features_path[index_metric], image_name + cfg.post_image_name_separator + current_post_fix)
images_path.append(img_path)
else:
img_path = features_images_list[index_metric][index_image]
images_path.append(os.path.join(label_features_path[index_metric], img_path))
if label == cfg.noisy_folder:
line = '1;'
else:
line = '0;'
# compute line information with all images paths
for id_path, img_path in enumerate(images_path):
if id_path < len(images_path) - 1:
line = line + img_path + '::'
else:
line = line + img_path
line = line + '\n'
if id_zone in train_zones:
train_file_data.append(line)
else:
test_file_data.append(line)
train_file = open(output_train_filename, 'w')
test_file = open(output_test_filename, 'w')
random.shuffle(train_file_data)
random.shuffle(test_file_data)
for line in train_file_data:
train_file.write(line)
for line in test_file_data:
test_file.write(line)
train_file.close()
test_file.close()
def generate_data(transformation, _dataset_path, _output, _human_thresholds,
_replace):
"""
@brief Method which generates all .csv files from scenes
@return nothing
"""
# path is the default dataset path
scenes = os.listdir(_dataset_path)
n_scenes = len(scenes)
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
print('Scene {0} of {1} ({2})'.format((id_scene + 1), n_scenes,
folder_scene))
scene_path = os.path.join(_dataset_path, folder_scene)
output_scene_path = os.path.join(cfg.output_data_generated, _output,
folder_scene)
# construct each zones folder name
zones_folder = []
features_folder = []
if folder_scene in _human_thresholds:
zones_threshold = _human_thresholds[folder_scene]
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone" + index_str
zones_folder.append(current_zone)
zone_path = os.path.join(output_scene_path, current_zone)
# custom path for feature
feature_path = os.path.join(zone_path,
transformation.getName())
if not os.path.exists(feature_path):
os.makedirs(feature_path)
# custom path for interval of reconstruction and feature
feature_interval_path = os.path.join(
zone_path, transformation.getTransformationPath())
features_folder.append(feature_interval_path)
if not os.path.exists(feature_interval_path):
os.makedirs(feature_interval_path)
# create for each zone the labels folder
labels = [cfg.not_noisy_folder, cfg.noisy_folder]
for label in labels:
label_folder = os.path.join(feature_interval_path, label)
if not os.path.exists(label_folder):
os.makedirs(label_folder)
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
number_scene_image = len(scene_images)
# for each images
for id_img, img_path in enumerate(scene_images):
current_img = Image.open(img_path)
img_blocks = divide_in_blocks(current_img, cfg.sub_image_size)
current_quality_index = int(get_scene_image_quality(img_path))
for id_block, block in enumerate(img_blocks):
##########################
# Image computation part #
##########################
label_path = features_folder[id_block]
# get label folder for block
if current_quality_index > zones_threshold[id_block]:
label_path = os.path.join(label_path,
cfg.not_noisy_folder)
else:
label_path = os.path.join(label_path, cfg.noisy_folder)
# check if necessary to compute or not images
# Disable use of data augmentation for the moment
# Data augmentation!
# rotations = [0, 90, 180, 270]
#img_flip_labels = ['original', 'horizontal', 'vertical', 'both']
# img_flip_labels = ['original', 'horizontal']
# output_images_path = []
# check_path_exists = []
# # rotate and flip image to increase dataset size
# for id, flip_label in enumerate(img_flip_labels):
# for rotation in rotations:
# output_reconstructed_filename = img_path.split('/')[-1].replace('.png', '') + '_' + zones_folder[id_block] + cfg.post_image_name_separator
# output_reconstructed_filename = output_reconstructed_filename + flip_label + '_' + str(rotation) + '.png'
# output_reconstructed_path = os.path.join(label_path, output_reconstructed_filename)
# if os.path.exists(output_reconstructed_path):
# check_path_exists.append(True)
# else:
# check_path_exists.append(False)
# output_images_path.append(output_reconstructed_path)
# compute only if not exists or necessary to replace
# if _replace or not np.array(check_path_exists).all():
# compute image
# pass block to grey level
# output_block = transformation.getTransformedImage(block)
# output_block = np.array(output_block, 'uint8')
# # current output image
# output_block_img = Image.fromarray(output_block)
#horizontal_img = output_block_img.transpose(Image.FLIP_LEFT_RIGHT)
#vertical_img = output_block_img.transpose(Image.FLIP_TOP_BOTTOM)
#both_img = output_block_img.transpose(Image.TRANSPOSE)
#flip_images = [output_block_img, horizontal_img, vertical_img, both_img]
#flip_images = [output_block_img, horizontal_img]
# Only current image img currenlty
# flip_images = [output_block_img]
# # rotate and flip image to increase dataset size
# counter_index = 0 # get current path index
# for id, flip in enumerate(flip_images):
# for rotation in rotations:
# if _replace or not check_path_exists[counter_index]:
# rotated_output_img = flip.rotate(rotation)
# rotated_output_img.save(output_images_path[counter_index])
# counter_index +=1
if _replace:
_, filename = os.path.split(img_path)
# build of output image filename
filename = filename.replace('.png', '')
filename_parts = filename.split('_')
# get samples : `00XXX`
n_samples = filename_parts[-1]
del filename_parts[-1]
# `p3d_XXXXXX`
output_reconstructed = '_'.join(filename_parts)
output_reconstructed_filename = output_reconstructed + '_' + zones_folder[
id_block] + '_' + n_samples + '.png'
output_reconstructed_path = os.path.join(
label_path, output_reconstructed_filename)
output_block = transformation.getTransformedImage(
block)
output_block = np.array(output_block, 'uint8')
# current output image
output_block_img = Image.fromarray(output_block)
output_block_img.save(output_reconstructed_path)
write_progress((id_img + 1) / number_scene_image)
print('\n')
print("{0}_{1} : end of data generation\n".format(
transformation.getName(), transformation.getParam()))
def generate_data(transformation):
"""
@brief Method which generates all .csv files from scenes
@return nothing
"""
scenes = os.listdir(path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
print(folder_scene)
scene_path = os.path.join(path, folder_scene)
config_file_path = os.path.join(scene_path, config_filename)
with open(config_file_path, "r") as config_file:
last_image_name = config_file.readline().strip()
prefix_image_name = config_file.readline().strip()
start_index_image = config_file.readline().strip()
end_index_image = config_file.readline().strip()
step_counter = int(config_file.readline().strip())
# construct each zones folder name
zones_folder = []
features_folder = []
zones_threshold = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone"+index_str
zones_folder.append(current_zone)
zone_path = os.path.join(scene_path, current_zone)
with open(os.path.join(zone_path, cfg.seuil_expe_filename)) as f:
zones_threshold.append(int(f.readline()))
# custom path for feature
feature_path = os.path.join(zone_path, transformation.getName())
if not os.path.exists(feature_path):
os.makedirs(feature_path)
# custom path for interval of reconstruction and feature
feature_interval_path = os.path.join(zone_path, transformation.getTransformationPath())
features_folder.append(feature_interval_path)
if not os.path.exists(feature_interval_path):
os.makedirs(feature_interval_path)
# create for each zone the labels folder
labels = [cfg.not_noisy_folder, cfg.noisy_folder]
for label in labels:
label_folder = os.path.join(feature_interval_path, label)
if not os.path.exists(label_folder):
os.makedirs(label_folder)
# get all images of folder
scene_images = sorted([os.path.join(scene_path, img) for img in os.listdir(scene_path) if cfg.scene_image_extension in img])
number_scene_image = len(scene_images)
# for each images
for id_img, img_path in enumerate(scene_images):
current_img = Image.open(img_path)
img_blocks = divide_in_blocks(current_img, cfg.keras_img_size)
current_quality_index = int(get_scene_image_quality(img_path))
for id_block, block in enumerate(img_blocks):
##########################
# Image computation part #
##########################
# pass block to grey level
output_block = transformation.getTransformedImage(block)
output_block = np.array(output_block, 'uint8')
# current output image
output_block_img = Image.fromarray(output_block)
label_path = features_folder[id_block]
# get label folder for block
if current_quality_index > zones_threshold[id_block]:
label_path = os.path.join(label_path, cfg.not_noisy_folder)
else:
label_path = os.path.join(label_path, cfg.noisy_folder)
# Data augmentation!
rotations = [0, 90, 180, 270]
img_flip_labels = ['original', 'horizontal', 'vertical', 'both']
horizontal_img = output_block_img.transpose(Image.FLIP_LEFT_RIGHT)
vertical_img = output_block_img.transpose(Image.FLIP_TOP_BOTTOM)
both_img = output_block_img.transpose(Image.TRANSPOSE)
flip_images = [output_block_img, horizontal_img, vertical_img, both_img]
# rotate and flip image to increase dataset size
for id, flip in enumerate(flip_images):
for rotation in rotations:
rotated_output_img = flip.rotate(rotation)
output_reconstructed_filename = img_path.split('/')[-1].replace('.png', '') + '_' + zones_folder[id_block] + cfg.post_image_name_separator
output_reconstructed_filename = output_reconstructed_filename + img_flip_labels[id] + '_' + str(rotation) + '.png'
output_reconstructed_path = os.path.join(label_path, output_reconstructed_filename)
rotated_output_img.save(output_reconstructed_path)
print(transformation.getName() + "_" + folder_scene + " - " + "{0:.2f}".format(((id_img + 1) / number_scene_image)* 100.) + "%")
sys.stdout.write("\033[F")
print('\n')
print("%s_%s : end of data generation\n" % (transformation.getName(), transformation.getParam()))
def main():
p_custom = False
parser = argparse.ArgumentParser(
description="Script which predicts threshold using specific model")
parser.add_argument('--interval',
type=str,
help='Interval value to keep from svd',
default='"0, 200"')
parser.add_argument('--model',
type=str,
help='.joblib or .json file (sklearn or keras model)')
parser.add_argument('--mode',
type=str,
help='Kind of normalization level wished',
choices=normalization_choices)
parser.add_argument('--feature',
type=str,
help='feature data choice',
choices=features_choices)
#parser.add_argument('--limit_detection', type=int, help='Specify number of same prediction to stop threshold prediction', default=2)
parser.add_argument(
'--custom',
type=str,
help='Name of custom min max file if use of renormalization of data',
default=False)
args = parser.parse_args()
# keep p_interval as it is
p_interval = args.interval
p_model_file = args.model
p_mode = args.mode
p_feature = args.feature
#p_limit = args.limit
p_custom = args.custom
scenes = os.listdir(scenes_path)
scenes = [s for s in scenes if s in maxwell_scenes]
print(scenes)
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
# only take in consideration maxwell scenes
if folder_scene in maxwell_scenes:
print(folder_scene)
scene_path = os.path.join(scenes_path, folder_scene)
threshold_expes = []
threshold_expes_found = []
block_predictions_str = []
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
start_quality_image = dt.get_scene_image_quality(scene_images[0])
end_quality_image = dt.get_scene_image_quality(scene_images[-1])
# using first two images find the step of quality used
quality_step_image = dt.get_scene_image_quality(
scene_images[1]) - start_quality_image
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
zone_folder = "zone" + index_str
threshold_path_file = os.path.join(
os.path.join(scene_path, zone_folder),
threshold_expe_filename)
with open(threshold_path_file) as f:
threshold = int(f.readline())
threshold_expes.append(threshold)
# Initialize default data to get detected model threshold found
threshold_expes_found.append(
end_quality_image) # by default use max
block_predictions_str.append(index_str + ";" + p_model_file +
";" + str(threshold) + ";" +
str(start_quality_image) + ";" +
str(quality_step_image))
# for each images
for img_path in scene_images:
current_img = Image.open(img_path)
current_quality_image = dt.get_scene_image_quality(img_path)
img_blocks = segmentation.divide_in_blocks(
current_img, (200, 200))
for id_block, block in enumerate(img_blocks):
# check only if necessary for this scene (not already detected)
#if not threshold_expes_detected[id_block]:
tmp_file_path = tmp_filename.replace(
'__model__',
p_model_file.split('/')[-1].replace('.joblib', '_'))
block.save(tmp_file_path)
python_cmd_line = "python prediction/predict_noisy_image_svd.py --image {0} --interval '{1}' --model {2} --mode {3} --feature {4}"
python_cmd = python_cmd_line.format(
tmp_file_path, p_interval, p_model_file, p_mode,
p_feature)
# specify use of custom file for min max normalization
if p_custom:
python_cmd = python_cmd + ' --custom ' + p_custom
## call command ##
p = subprocess.Popen(python_cmd,
stdout=subprocess.PIPE,
shell=True)
(output, err) = p.communicate()
## Wait for result ##
p_status = p.wait()
prediction = int(output)
# save here in specific file of block all the predictions done
block_predictions_str[id_block] = block_predictions_str[
id_block] + ";" + str(prediction)
print(
str(id_block) + " : " + str(current_quality_image) +
"/" + str(threshold_expes[id_block]) + " => " +
str(prediction))
print("------------------------")
print("Scene " + str(id_scene + 1) + "/" + str(len(scenes)))
print("------------------------")
# end of scene => display of results
# construct path using model name for saving threshold map folder
model_threshold_path = os.path.join(
threshold_map_folder,
p_model_file.split('/')[-1].replace('.joblib', ''))
# create threshold model path if necessary
if not os.path.exists(model_threshold_path):
os.makedirs(model_threshold_path)
map_filename = os.path.join(model_threshold_path,
simulation_curves_zones + folder_scene)
f_map = open(map_filename, 'w')
for line in block_predictions_str:
f_map.write(line + '\n')
f_map.close()
print("Scene " + str(id_scene + 1) + "/" +
str(len(maxwell_scenes)) + " Done..")
print("------------------------")
print("Model predictions are saved into %s" % map_filename)
def estimate(estimator, arr):
if estimator == 'variance':
return np.var(arr)
if estimator == 'l_variance':
return np.var(transform.get_LAB_L(arr))
if estimator == 'mean':
return np.mean(arr)
if estimator == 'l_mean':
return np.mean(transform.get_LAB_L(arr))
if estimator == 'sv_struct_all':
return transform.get_LAB_L_SVD_s(arr)[0:50]
if estimator == 'sv_struct':
return np.mean(transform.get_LAB_L_SVD_s(arr)[0:50])
if estimator == 'sv_noise_all':
return transform.get_LAB_L_SVD_s(arr)[50:]
if estimator == 'sv_noise':
return np.mean(transform.get_LAB_L_SVD_s(arr)[50:])
if estimator == 'sobel':
lab_img = transform.get_LAB_L(arr)
# 1. extract sobol complexity with kernel 3
sobelx = cv2.Sobel(lab_img, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(lab_img, cv2.CV_64F, 0, 1, ksize=5)
sobel_mag = np.array(np.hypot(sobelx, sobely), 'uint8') # magnitude
return np.std(sobel_mag)
if estimator == 'l_kolmogorov':
lab_img = transform.get_LAB_L(arr)
bytes_data = lab_img.tobytes()
compress_data = gzip.compress(bytes_data)
mo_size = sys.getsizeof(compress_data) / 1024.
go_size = mo_size / 1024.
return np.float64(go_size)
if estimator == 'l_sv_entropy_blocks':
# get L channel
L_channel = transform.get_LAB_L(arr)
# split in n block
blocks = segmentation.divide_in_blocks(L_channel, (20, 20))
entropy_list = []
for block in blocks:
reduced_sigma = compression.get_SVD_s(block)
reduced_entropy = get_entropy(reduced_sigma)
entropy_list.append(reduced_entropy)
return entropy_list
if estimator == '26_attributes':
img_width, img_height = 200, 200
lab_img = transform.get_LAB_L(arr)
arr = np.array(lab_img)
# compute all filters statistics
def get_stats(arr, I_filter):
e1 = np.abs(arr - I_filter)
L = np.array(e1)
mu0 = np.mean(L)
A = L - mu0
H = A * A
E = np.sum(H) / (img_width * img_height)
P = np.sqrt(E)
return mu0, P
# return np.mean(I_filter), np.std(I_filter)
stats = []
kernel = np.ones((3, 3), np.float32) / 9
stats.append(get_stats(arr, cv2.filter2D(arr, -1, kernel)))
kernel = np.ones((5, 5), np.float32) / 25
stats.append(get_stats(arr, cv2.filter2D(arr, -1, kernel)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 0.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 1)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (3, 3), 1.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 0.5)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 1)))
stats.append(get_stats(arr, cv2.GaussianBlur(arr, (5, 5), 1.5)))
stats.append(get_stats(arr, medfilt2d(arr, [3, 3])))
stats.append(get_stats(arr, medfilt2d(arr, [5, 5])))
stats.append(get_stats(arr, wiener(arr, [3, 3])))
stats.append(get_stats(arr, wiener(arr, [5, 5])))
wave = w2d(arr, 'db1', 2)
stats.append(get_stats(arr, np.array(wave, 'float64')))
data = []
for stat in stats:
data.append(stat[0])
for stat in stats:
data.append(stat[1])
data = np.array(data)
return data
if estimator == 'statistics_extended':
# data = estimate('26_attributes', arr)
data = np.empty(0)
# add kolmogorov complexity
bytes_data = np.array(arr).tobytes()
compress_data = gzip.compress(bytes_data)
mo_size = sys.getsizeof(compress_data) / 1024.
go_size = mo_size / 1024.
data = np.append(data, go_size)
lab_img = transform.get_LAB_L(arr)
arr = np.array(lab_img)
# add of svd entropy
svd_entropy = utils.get_entropy(compression.get_SVD_s(arr))
data = np.append(data, svd_entropy)
# add sobel complexity (kernel size of 3)
sobelx = cv2.Sobel(arr, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(arr, cv2.CV_64F, 0, 1, ksize=3)
sobel_mag = np.array(np.hypot(sobelx, sobely), 'uint8') # magnitude
data = np.append(data, np.std(sobel_mag))
# add sobel complexity (kernel size of 5)
sobelx = cv2.Sobel(arr, cv2.CV_64F, 1, 0, ksize=5)
sobely = cv2.Sobel(arr, cv2.CV_64F, 0, 1, ksize=5)
sobel_mag = np.array(np.hypot(sobelx, sobely), 'uint8') # magnitude
data = np.append(data, np.std(sobel_mag))
return data
def get_image_features(data_type, block):
"""
Method which returns the data type expected
"""
if data_type == 'lab':
block_file_path = '/tmp/lab_img.png'
block.save(block_file_path)
data = transform.get_LAB_L_SVD_s(Image.open(block_file_path))
if data_type == 'mscn':
img_mscn_revisited = transform.rgb_to_mscn(block)
# save tmp as img
img_output = Image.fromarray(img_mscn_revisited.astype('uint8'), 'L')
mscn_revisited_file_path = '/tmp/mscn_revisited_img.png'
img_output.save(mscn_revisited_file_path)
img_block = Image.open(mscn_revisited_file_path)
# extract from temp image
data = compression.get_SVD_s(img_block)
"""if data_type == 'mscn':
img_gray = np.array(color.rgb2gray(np.asarray(block))*255, 'uint8')
img_mscn = transform.calculate_mscn_coefficients(img_gray, 7)
img_mscn_norm = transform.normalize_2D_arr(img_mscn)
img_mscn_gray = np.array(img_mscn_norm*255, 'uint8')
data = compression.get_SVD_s(img_mscn_gray)
"""
if data_type == 'low_bits_6':
low_bits_6 = transform.rgb_to_LAB_L_low_bits(block, 6)
data = compression.get_SVD_s(low_bits_6)
if data_type == 'low_bits_5':
low_bits_5 = transform.rgb_to_LAB_L_low_bits(block, 5)
data = compression.get_SVD_s(low_bits_5)
if data_type == 'low_bits_4':
low_bits_4 = transform.rgb_to_LAB_L_low_bits(block, 4)
data = compression.get_SVD_s(low_bits_4)
if data_type == 'low_bits_3':
low_bits_3 = transform.rgb_to_LAB_L_low_bits(block, 3)
data = compression.get_SVD_s(low_bits_3)
if data_type == 'low_bits_2':
low_bits_2 = transform.rgb_to_LAB_L_low_bits(block, 2)
data = compression.get_SVD_s(low_bits_2)
if data_type == 'low_bits_4_shifted_2':
data = compression.get_SVD_s(transform.rgb_to_LAB_L_bits(
block, (3, 6)))
if data_type == 'sub_blocks_stats':
block = np.asarray(block)
width, height, _ = block.shape
sub_width, sub_height = int(width / 4), int(height / 4)
sub_blocks = segmentation.divide_in_blocks(block,
(sub_width, sub_height))
data = []
for sub_b in sub_blocks:
# by default use the whole lab L canal
l_svd_data = np.array(transform.get_LAB_L_SVD_s(sub_b))
# get information we want from svd
data.append(np.mean(l_svd_data))
data.append(np.median(l_svd_data))
data.append(np.percentile(l_svd_data, 25))
data.append(np.percentile(l_svd_data, 75))
data.append(np.var(l_svd_data))
area_under_curve = utils.integral_area_trapz(l_svd_data, dx=100)
data.append(area_under_curve)
# convert into numpy array after computing all stats
data = np.asarray(data)
if data_type == 'sub_blocks_stats_reduced':
block = np.asarray(block)
width, height, _ = block.shape
sub_width, sub_height = int(width / 4), int(height / 4)
sub_blocks = segmentation.divide_in_blocks(block,
(sub_width, sub_height))
data = []
for sub_b in sub_blocks:
# by default use the whole lab L canal
l_svd_data = np.array(transform.get_LAB_L_SVD_s(sub_b))
# get information we want from svd
data.append(np.mean(l_svd_data))
data.append(np.median(l_svd_data))
data.append(np.percentile(l_svd_data, 25))
data.append(np.percentile(l_svd_data, 75))
data.append(np.var(l_svd_data))
# convert into numpy array after computing all stats
data = np.asarray(data)
if data_type == 'sub_blocks_area':
block = np.asarray(block)
width, height, _ = block.shape
sub_width, sub_height = int(width / 8), int(height / 8)
sub_blocks = segmentation.divide_in_blocks(block,
(sub_width, sub_height))
data = []
for sub_b in sub_blocks:
# by default use the whole lab L canal
l_svd_data = np.array(transform.get_LAB_L_SVD_s(sub_b))
area_under_curve = utils.integral_area_trapz(l_svd_data, dx=50)
data.append(area_under_curve)
# convert into numpy array after computing all stats
data = np.asarray(data)
if data_type == 'sub_blocks_area_normed':
block = np.asarray(block)
width, height, _ = block.shape
sub_width, sub_height = int(width / 8), int(height / 8)
sub_blocks = segmentation.divide_in_blocks(block,
(sub_width, sub_height))
data = []
for sub_b in sub_blocks:
# by default use the whole lab L canal
l_svd_data = np.array(transform.get_LAB_L_SVD_s(sub_b))
l_svd_data = utils.normalize_arr(l_svd_data)
area_under_curve = utils.integral_area_trapz(l_svd_data, dx=50)
data.append(area_under_curve)
# convert into numpy array after computing all stats
data = np.asarray(data)
if data_type == 'mscn_var_4':
data = _get_mscn_variance(block, (100, 100))
if data_type == 'mscn_var_16':
data = _get_mscn_variance(block, (50, 50))
if data_type == 'mscn_var_64':
data = _get_mscn_variance(block, (25, 25))
if data_type == 'mscn_var_16_max':
data = _get_mscn_variance(block, (50, 50))
data = np.asarray(data)
size = int(len(data) / 4)
indices = data.argsort()[-size:][::-1]
data = data[indices]
if data_type == 'mscn_var_64_max':
data = _get_mscn_variance(block, (25, 25))
data = np.asarray(data)
size = int(len(data) / 4)
indices = data.argsort()[-size:][::-1]
data = data[indices]
if data_type == 'ica_diff':
current_image = transform.get_LAB_L(block)
ica = FastICA(n_components=50)
ica.fit(current_image)
image_ica = ica.fit_transform(current_image)
image_restored = ica.inverse_transform(image_ica)
final_image = utils.normalize_2D_arr(image_restored)
final_image = np.array(final_image * 255, 'uint8')
sv_values = utils.normalize_arr(compression.get_SVD_s(current_image))
ica_sv_values = utils.normalize_arr(compression.get_SVD_s(final_image))
data = abs(np.array(sv_values) - np.array(ica_sv_values))
if data_type == 'svd_trunc_diff':
current_image = transform.get_LAB_L(block)
svd = TruncatedSVD(n_components=30, n_iter=100, random_state=42)
transformed_image = svd.fit_transform(current_image)
restored_image = svd.inverse_transform(transformed_image)
reduced_image = (current_image - restored_image)
U, s, V = compression.get_SVD(reduced_image)
data = s
if data_type == 'ipca_diff':
current_image = transform.get_LAB_L(block)
transformer = IncrementalPCA(n_components=20, batch_size=25)
transformed_image = transformer.fit_transform(current_image)
restored_image = transformer.inverse_transform(transformed_image)
reduced_image = (current_image - restored_image)
U, s, V = compression.get_SVD(reduced_image)
data = s
if data_type == 'svd_reconstruct':
reconstructed_interval = (90, 200)
begin, end = reconstructed_interval
lab_img = transform.get_LAB_L(block)
lab_img = np.array(lab_img, 'uint8')
U, s, V = lin_svd(lab_img, full_matrices=True)
smat = np.zeros((end - begin, end - begin), dtype=complex)
smat[:, :] = np.diag(s[begin:end])
output_img = np.dot(U[:, begin:end], np.dot(smat, V[begin:end, :]))
output_img = np.array(output_img, 'uint8')
data = compression.get_SVD_s(output_img)
if 'sv_std_filters' in data_type:
# convert into lab by default to apply filters
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
images = []
# Apply list of filter on arr
images.append(medfilt2d(arr, [3, 3]))
images.append(medfilt2d(arr, [5, 5]))
images.append(wiener(arr, [3, 3]))
images.append(wiener(arr, [5, 5]))
# By default computation of current block image
s_arr = compression.get_SVD_s(arr)
sv_vector = [s_arr]
# for each new image apply SVD and get SV
for img in images:
s = compression.get_SVD_s(img)
sv_vector.append(s)
sv_array = np.array(sv_vector)
_, length = sv_array.shape
sv_std = []
# normalize each SV vectors and compute standard deviation for each sub vectors
for i in range(length):
sv_array[:, i] = utils.normalize_arr(sv_array[:, i])
sv_std.append(np.std(sv_array[:, i]))
indices = []
if 'lowest' in data_type:
indices = utils.get_indices_of_lowest_values(sv_std, 200)
if 'highest' in data_type:
indices = utils.get_indices_of_highest_values(sv_std, 200)
# data are arranged following std trend computed
data = s_arr[indices]
# with the use of wavelet
if 'wave_sv_std_filters' in data_type:
# convert into lab by default to apply filters
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
images = []
# Apply list of filter on arr
images.append(medfilt2d(arr, [3, 3]))
# By default computation of current block image
s_arr = compression.get_SVD_s(arr)
sv_vector = [s_arr]
# for each new image apply SVD and get SV
for img in images:
s = compression.get_SVD_s(img)
sv_vector.append(s)
sv_array = np.array(sv_vector)
_, length = sv_array.shape
sv_std = []
# normalize each SV vectors and compute standard deviation for each sub vectors
for i in range(length):
sv_array[:, i] = utils.normalize_arr(sv_array[:, i])
sv_std.append(np.std(sv_array[:, i]))
indices = []
if 'lowest' in data_type:
indices = utils.get_indices_of_lowest_values(sv_std, 200)
if 'highest' in data_type:
indices = utils.get_indices_of_highest_values(sv_std, 200)
# data are arranged following std trend computed
data = s_arr[indices]
# with the use of wavelet
if 'sv_std_filters_full' in data_type:
# convert into lab by default to apply filters
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
images = []
# Apply list of filter on arr
kernel = np.ones((3, 3), np.float32) / 9
images.append(cv2.filter2D(arr, -1, kernel))
kernel = np.ones((5, 5), np.float32) / 25
images.append(cv2.filter2D(arr, -1, kernel))
images.append(cv2.GaussianBlur(arr, (3, 3), 0.5))
images.append(cv2.GaussianBlur(arr, (3, 3), 1))
images.append(cv2.GaussianBlur(arr, (3, 3), 1.5))
images.append(cv2.GaussianBlur(arr, (5, 5), 0.5))
images.append(cv2.GaussianBlur(arr, (5, 5), 1))
images.append(cv2.GaussianBlur(arr, (5, 5), 1.5))
images.append(medfilt2d(arr, [3, 3]))
images.append(medfilt2d(arr, [5, 5]))
images.append(wiener(arr, [3, 3]))
images.append(wiener(arr, [5, 5]))
wave = w2d(arr, 'db1', 2)
images.append(np.array(wave, 'float64'))
# By default computation of current block image
s_arr = compression.get_SVD_s(arr)
sv_vector = [s_arr]
# for each new image apply SVD and get SV
for img in images:
s = compression.get_SVD_s(img)
sv_vector.append(s)
sv_array = np.array(sv_vector)
_, length = sv_array.shape
sv_std = []
# normalize each SV vectors and compute standard deviation for each sub vectors
for i in range(length):
sv_array[:, i] = utils.normalize_arr(sv_array[:, i])
sv_std.append(np.std(sv_array[:, i]))
indices = []
if 'lowest' in data_type:
indices = utils.get_indices_of_lowest_values(sv_std, 200)
if 'highest' in data_type:
indices = utils.get_indices_of_highest_values(sv_std, 200)
# data are arranged following std trend computed
data = s_arr[indices]
if 'sv_entropy_std_filters' in data_type:
lab_img = transform.get_LAB_L(block)
arr = np.array(lab_img)
images = []
kernel = np.ones((3, 3), np.float32) / 9
images.append(cv2.filter2D(arr, -1, kernel))
kernel = np.ones((5, 5), np.float32) / 25
images.append(cv2.filter2D(arr, -1, kernel))
images.append(cv2.GaussianBlur(arr, (3, 3), 0.5))
images.append(cv2.GaussianBlur(arr, (3, 3), 1))
images.append(cv2.GaussianBlur(arr, (3, 3), 1.5))
images.append(cv2.GaussianBlur(arr, (5, 5), 0.5))
images.append(cv2.GaussianBlur(arr, (5, 5), 1))
images.append(cv2.GaussianBlur(arr, (5, 5), 1.5))
images.append(medfilt2d(arr, [3, 3]))
images.append(medfilt2d(arr, [5, 5]))
images.append(wiener(arr, [3, 3]))
images.append(wiener(arr, [5, 5]))
wave = w2d(arr, 'db1', 2)
images.append(np.array(wave, 'float64'))
sv_vector = []
sv_entropy_list = []
# for each new image apply SVD and get SV
for img in images:
s = compression.get_SVD_s(img)
sv_vector.append(s)
sv_entropy = [
utils.get_entropy_contribution_of_i(s, id_sv)
for id_sv, sv in enumerate(s)
]
sv_entropy_list.append(sv_entropy)
sv_std = []
sv_array = np.array(sv_vector)
_, length = sv_array.shape
# normalize each SV vectors and compute standard deviation for each sub vectors
for i in range(length):
sv_array[:, i] = utils.normalize_arr(sv_array[:, i])
sv_std.append(np.std(sv_array[:, i]))
indices = []
if 'lowest' in data_type:
indices = utils.get_indices_of_lowest_values(sv_std, 200)
if 'highest' in data_type:
indices = utils.get_indices_of_highest_values(sv_std, 200)
# data are arranged following std trend computed
s_arr = compression.get_SVD_s(arr)
data = s_arr[indices]
if 'convolutional_kernels' in data_type:
sub_zones = segmentation.divide_in_blocks(block, (20, 20))
data = []
diff_std_list_3 = []
diff_std_list_5 = []
diff_mean_list_3 = []
diff_mean_list_5 = []
plane_std_list_3 = []
plane_std_list_5 = []
plane_mean_list_3 = []
plane_mean_list_5 = []
plane_max_std_list_3 = []
plane_max_std_list_5 = []
plane_max_mean_list_3 = []
plane_max_mean_list_5 = []
for sub_zone in sub_zones:
l_img = transform.get_LAB_L(sub_zone)
normed_l_img = utils.normalize_2D_arr(l_img)
# bilateral with window of size (3, 3)
normed_diff = convolution.convolution2D(normed_l_img,
kernels.min_bilateral_diff,
(3, 3))
std_diff = np.std(normed_diff)
mean_diff = np.mean(normed_diff)
diff_std_list_3.append(std_diff)
diff_mean_list_3.append(mean_diff)
# bilateral with window of size (5, 5)
normed_diff = convolution.convolution2D(normed_l_img,
kernels.min_bilateral_diff,
(5, 5))
std_diff = np.std(normed_diff)
mean_diff = np.mean(normed_diff)
diff_std_list_5.append(std_diff)
diff_mean_list_5.append(mean_diff)
# plane mean with window of size (3, 3)
normed_plane_mean = convolution.convolution2D(
normed_l_img, kernels.plane_mean, (3, 3))
std_plane_mean = np.std(normed_plane_mean)
mean_plane_mean = np.mean(normed_plane_mean)
plane_std_list_3.append(std_plane_mean)
plane_mean_list_3.append(mean_plane_mean)
# plane mean with window of size (5, 5)
normed_plane_mean = convolution.convolution2D(
normed_l_img, kernels.plane_mean, (5, 5))
std_plane_mean = np.std(normed_plane_mean)
mean_plane_mean = np.mean(normed_plane_mean)
plane_std_list_5.append(std_plane_mean)
plane_mean_list_5.append(mean_plane_mean)
# plane max error with window of size (3, 3)
normed_plane_max = convolution.convolution2D(
normed_l_img, kernels.plane_max_error, (3, 3))
std_plane_max = np.std(normed_plane_max)
mean_plane_max = np.mean(normed_plane_max)
plane_max_std_list_3.append(std_plane_max)
plane_max_mean_list_3.append(mean_plane_max)
# plane max error with window of size (5, 5)
normed_plane_max = convolution.convolution2D(
normed_l_img, kernels.plane_max_error, (5, 5))
std_plane_max = np.std(normed_plane_max)
mean_plane_max = np.mean(normed_plane_max)
plane_max_std_list_5.append(std_plane_max)
plane_max_mean_list_5.append(mean_plane_max)
diff_std_list_3 = np.array(diff_std_list_3)
diff_std_list_5 = np.array(diff_std_list_5)
diff_mean_list_3 = np.array(diff_mean_list_3)
diff_mean_list_5 = np.array(diff_mean_list_5)
plane_std_list_3 = np.array(plane_std_list_3)
plane_std_list_5 = np.array(plane_std_list_5)
plane_mean_list_3 = np.array(plane_mean_list_3)
plane_mean_list_5 = np.array(plane_mean_list_5)
plane_max_std_list_3 = np.array(plane_max_std_list_3)
plane_max_std_list_5 = np.array(plane_max_std_list_5)
plane_max_mean_list_3 = np.array(plane_max_mean_list_3)
plane_max_mean_list_5 = np.array(plane_max_mean_list_5)
if 'std_max_blocks' in data_type:
data.append(np.std(diff_std_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.std(diff_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.std(diff_std_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.std(diff_mean_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_std_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_std_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_mean_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_max_std_list_3[0:int(len(sub_zones) /
5)]))
data.append(
np.std(plane_max_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.std(plane_max_std_list_5[0:int(len(sub_zones) /
5)]))
data.append(
np.std(plane_max_mean_list_5[0:int(len(sub_zones) / 5)]))
if 'mean_max_blocks' in data_type:
data.append(np.mean(diff_std_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.mean(diff_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.mean(diff_std_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.mean(diff_mean_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.mean(plane_std_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.mean(plane_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(np.mean(plane_std_list_5[0:int(len(sub_zones) / 5)]))
data.append(np.mean(plane_mean_list_5[0:int(len(sub_zones) / 5)]))
data.append(
np.mean(plane_max_std_list_3[0:int(len(sub_zones) / 5)]))
data.append(
np.mean(plane_max_mean_list_3[0:int(len(sub_zones) / 5)]))
data.append(
np.mean(plane_max_std_list_5[0:int(len(sub_zones) / 5)]))
data.append(
np.mean(plane_max_mean_list_5[0:int(len(sub_zones) / 5)]))
if 'std_normed' in data_type:
data.append(np.std(diff_std_list_3))
data.append(np.std(diff_mean_list_3))
data.append(np.std(diff_std_list_5))
data.append(np.std(diff_mean_list_5))
data.append(np.std(plane_std_list_3))
data.append(np.std(plane_mean_list_3))
data.append(np.std(plane_std_list_5))
data.append(np.std(plane_mean_list_5))
data.append(np.std(plane_max_std_list_3))
data.append(np.std(plane_max_mean_list_3))
data.append(np.std(plane_max_std_list_5))
data.append(np.std(plane_max_mean_list_5))
if 'mean_normed' in data_type:
data.append(np.mean(diff_std_list_3))
data.append(np.mean(diff_mean_list_3))
data.append(np.mean(diff_std_list_5))
data.append(np.mean(diff_mean_list_5))
data.append(np.mean(plane_std_list_3))
data.append(np.mean(plane_mean_list_3))
data.append(np.mean(plane_std_list_5))
data.append(np.mean(plane_mean_list_5))
data.append(np.mean(plane_max_std_list_3))
data.append(np.mean(plane_max_mean_list_3))
data.append(np.mean(plane_max_std_list_5))
data.append(np.mean(plane_max_mean_list_5))
data = np.array(data)
if data_type == 'convolutional_kernel_stats_svd':
l_img = transform.get_LAB_L(block)
normed_l_img = utils.normalize_2D_arr(l_img)
# bilateral with window of size (5, 5)
normed_diff = convolution.convolution2D(normed_l_img,
kernels.min_bilateral_diff,
(5, 5))
# getting sigma vector from SVD compression
s = compression.get_SVD_s(normed_diff)
data = s
if data_type == 'svd_entropy':
l_img = transform.get_LAB_L(block)
blocks = segmentation.divide_in_blocks(l_img, (20, 20))
values = []
for b in blocks:
sv = compression.get_SVD_s(b)
values.append(utils.get_entropy(sv))
data = np.array(values)
if data_type == 'svd_entropy_20':
l_img = transform.get_LAB_L(block)
blocks = segmentation.divide_in_blocks(l_img, (20, 20))
values = []
for b in blocks:
sv = compression.get_SVD_s(b)
values.append(utils.get_entropy(sv))
data = np.array(values)
if data_type == 'svd_entropy_noise_20':
l_img = transform.get_LAB_L(block)
blocks = segmentation.divide_in_blocks(l_img, (20, 20))
values = []
for b in blocks:
sv = compression.get_SVD_s(b)
sv_size = len(sv)
values.append(utils.get_entropy(sv[int(sv_size / 4):]))
data = np.array(values)
return data
def main():
parser = argparse.ArgumentParser(
description=
"Check complexity of each zone of scene using estimator during rendering"
)
parser.add_argument(
'--folder',
type=str,
help='folder where scenes with png scene file are stored')
parser.add_argument('--estimators',
type=str,
help='list of estimators',
default='l_mean,l_variance')
parser.add_argument('--output',
type=str,
help='output data filename',
required=True)
args = parser.parse_args()
p_folder = args.folder
p_estimators = [i.strip() for i in args.estimators.split(',')]
p_output = args.output
print(p_estimators)
folders = [f for f in os.listdir(p_folder) if 'min_max' not in f]
n_zones = 16
if not os.path.exists(data_output):
os.makedirs(data_output)
datafile = open(os.path.join(data_output, p_output), 'w')
for i, scene in enumerate(sorted(folders)):
zones = []
zones_indices = np.arange(n_zones)
for _ in zones_indices:
zones.append([])
scene_folder = os.path.join(p_folder, scene)
# get all images and extract estimator for each blocks
images = sorted([i for i in os.listdir(scene_folder) if '.png' in i])
# get reference image
img_path = os.path.join(scene_folder, images[0])
img_arr = np.array(Image.open(img_path))
blocks = segmentation.divide_in_blocks(img_arr, (200, 200))
for index, b in enumerate(blocks):
# extract data and write into file
x = []
for estimator in p_estimators:
estimated = estimate(estimator, b)
if not isinstance(estimated, np.float64):
for v in estimated:
x.append(v)
else:
x.append(estimated)
line = scene + ';' + img_path + ';' + str(index) + ';'
for v in x:
line += str(v) + ';'
line += '\n'
datafile.write(line)
write_progress((i * n_zones + index + 1) /
(float(len(folders)) * float(n_zones)))
datafile.close()
def display_svd_values(p_scene, p_interval, p_indices, p_zone, p_feature,
p_mode, p_step, p_norm, p_ylim):
"""
@brief Method which gives information about svd curves from zone of picture
@param p_scene, scene expected to show svd values
@param p_interval, interval [begin, end] of svd data to display
@param p_interval, interval [begin, end] of samples or minutes from render generation engine
@param p_zone, zone's identifier of picture
@param p_feature, feature computed to show
@param p_mode, normalization's mode
@param p_step, step of images indices
@param p_norm, normalization or not of selected svd data
@param p_ylim, ylim choice to better display of data
@return nothing
"""
scenes = os.listdir(path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
begin_data, end_data = p_interval
begin_index, end_index = p_indices
data_min_max_filename = os.path.join(path, p_feature + min_max_filename)
# go ahead each scenes
for folder_scene in scenes:
if p_scene == folder_scene:
scene_path = os.path.join(path, folder_scene)
# construct each zones folder name
zones_folder = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone" + index_str
zones_folder.append(current_zone)
zones_images_data = []
images_path = []
zone_folder = zones_folder[p_zone]
zone_path = os.path.join(scene_path, zone_folder)
# get threshold information
path_seuil = os.path.join(zone_path, seuil_expe_filename)
# open treshold path and get this information
with open(path_seuil, "r") as seuil_file:
seuil_learned = int(seuil_file.readline().strip())
threshold_image_found = False
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
# for each images
for img_path in scene_images:
current_quality_image = dt.get_scene_image_quality(img_path)
if current_quality_image % p_step == 0:
if current_quality_image >= begin_index and current_quality_image <= end_index:
images_path.append(img_path)
if seuil_learned < current_quality_image and not threshold_image_found:
threshold_image_found = True
threshold_image_zone = dt.get_scene_image_postfix(
img_path)
if img_path not in images_path:
images_path.append(img_path)
for img_path in images_path:
current_img = Image.open(img_path)
img_blocks = segmentation.divide_in_blocks(
current_img, (200, 200))
# getting expected block id
block = img_blocks[p_zone]
# get data from mode
# Here you can add the way you compute data
data = get_image_features(p_feature, block)
# TODO : improve part of this code to get correct min / max values
if p_norm:
data = data[begin_data:end_data]
##################
# Data mode part #
##################
if p_mode == 'svdne':
# getting max and min information from min_max_filename
if not p_norm:
with open(data_min_max_filename, 'r') as f:
min_val = float(f.readline())
max_val = float(f.readline())
else:
min_val = min_value_interval
max_val = max_value_interval
data = utils.normalize_arr_with_range(
data, min_val, max_val)
if p_mode == 'svdn':
data = utils.normalize_arr(data)
if not p_norm:
zones_images_data.append(data[begin_data:end_data])
else:
zones_images_data.append(data)
fig, ax = plt.subplots(figsize=(30, 22))
ax.set_facecolor('#FFFFFF')
# plt.title(p_scene + ' scene (zone ' + str(p_zone) + ') interval information SVD['+ str(begin_data) +', '+ str(end_data) +'], from scenes indices [' + str(begin_index) + ', '+ str(end_index) + '], ' + p_feature + ' feature, ' + p_mode + ', with step of ' + str(p_step) + ', svd norm ' + str(p_norm), fontsize=24)
ax.set_ylabel('Component values', fontsize=28)
ax.set_xlabel('Vector features', fontsize=28)
ax.tick_params(labelsize=22)
for id, data in enumerate(zones_images_data):
p_label = p_scene + "_" + dt.get_scene_image_postfix(
images_path[id])
if int(dt.get_scene_image_postfix(
images_path[id])) == int(threshold_image_zone):
ax.plot(data,
label=p_label + ' (zone ' + str(p_zone) +
' threshold)',
lw=4,
color='red')
else:
ax.plot(data, label=p_label)
plt.legend(bbox_to_anchor=(0.60, 0.98),
loc=2,
borderaxespad=0.2,
fontsize=24)
start_ylim, end_ylim = p_ylim
plt.ylim(start_ylim, end_ylim)
plot_name = p_scene + '_zone_' + str(
p_zone) + '_' + p_feature + '_' + str(
p_step) + '_' + p_mode + '_' + str(p_norm) + '.png'
plt.savefig(plot_name, facecolor=ax.get_facecolor())
def main():
parser = argparse.ArgumentParser(
description="Compute sobel complexity on scene images")
parser.add_argument(
'--output',
type=str,
help='save complexity for each zone of each scene into file')
parser.add_argument('--ksize',
type=int,
help='sobel kernel size',
default=3)
parser.add_argument('--interval',
type=str,
help='svd interval to use',
default="0,200")
parser.add_argument(
'--imnorm',
type=int,
help="specify if image is normalized before computing something",
default=0,
choices=[0, 1])
args = parser.parse_args()
p_output = args.output
p_ksize = args.ksize
p_interval = tuple(map(int, args.interval.split(',')))
p_imnorm = args.imnorm
# create output path if not exists
p_output_path = os.path.join(cfg.output_data_folder, cfg.data_generated,
p_output)
if not os.path.exists(cfg.output_data_folder):
os.makedirs(os.path.join(cfg.output_data_folder, cfg.data_generated))
zones_list = []
# construct zones folder
for index in zones_indices:
index_str = str(index)
while len(index_str) < 2:
index_str = "0" + index_str
zones_list.append(cfg.zone_folder + index_str)
thresholds = {}
images_path = {}
number_of_images = 0
# create dictionnary of threshold and get all images path
for scene in scenes_list:
scene_path = os.path.join(dataset_folder, scene)
threshold_list = []
for zone in zones_list:
zone_path = os.path.join(scene_path, zone)
with open(os.path.join(zone_path, cfg.seuil_expe_filename),
'r') as f:
threshold_list.append(int(f.readline()))
thresholds[scene] = threshold_list
images_path[scene] = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
number_of_images = number_of_images + len(images_path[scene])
with open(p_output_path, 'w') as f:
print("Erase", p_output_path, "previous file if exists")
image_counter = 0
# compute complexity for each zones of each scene images
for scene in scenes_list:
image_indices = [
dt.get_scene_image_quality(img_path)
for img_path in images_path[scene]
]
blocks_complexity = []
# append empty list
for zone in zones_list:
blocks_complexity.append([])
for img_path in images_path[scene]:
blocks = segmentation.divide_in_blocks(Image.open(img_path),
(200, 200))
complexity_list = get_zone_sobel_svd_entropy(
blocks, p_interval, p_ksize, p_imnorm)
for index, complexity in enumerate(complexity_list):
blocks_complexity[index].append(complexity)
# write progress bar
write_progress((image_counter + 1) / number_of_images)
image_counter = image_counter + 1
# write data into files
with open(p_output_path, 'a') as f:
for index, zone in enumerate(zones_list):
f.write(scene + ';')
f.write(str(index) + ';')
f.write(zone + ';')
f.write(str(thresholds[scene][index]) + ';')
for index_img, img_quality in enumerate(image_indices):
f.write(str(img_quality))
if index_img + 1 < len(image_indices):
f.write(',')
f.write(';')
for index_v, v in enumerate(blocks_complexity[index]):
f.write(str(v))
if index_v + 1 < len(blocks_complexity[index]):
f.write(',')
f.write(';\n')
def main():
parser = argparse.ArgumentParser(
description=
"Check complexity of each zone of scene using estimator during rendering"
)
parser.add_argument(
'--folder',
type=str,
help='folder where scenes with png scene file are stored')
parser.add_argument('--estimator',
type=str,
help='metric to use to compare',
choices=estimators_list)
parser.add_argument('--ylim',
type=str,
help='0,100 : ylim expected',
default='')
parser.add_argument('--output',
type=str,
help='output folder name',
required=True)
args = parser.parse_args()
p_folder = args.folder
p_estimator = args.estimator
p_y_lim = args.ylim
p_output = args.output
folders = [f for f in os.listdir(p_folder) if 'min_max' not in f]
for scene in sorted(folders):
zones = []
zones_indices = np.arange(16)
for _ in zones_indices:
zones.append([])
print('Start extracting', p_estimator, 'for', scene)
scene_folder = os.path.join(p_folder, scene)
# get all images and extract estimator for each blocks
images = sorted([i for i in os.listdir(scene_folder) if '.png' in i])
n_images = float(len(images))
for i, img_name in enumerate(images):
img_path = os.path.join(scene_folder, img_name)
img_arr = np.array(Image.open(img_path))
blocks = segmentation.divide_in_blocks(img_arr, (200, 200))
for index, b in enumerate(blocks):
zones[index].append(estimate(p_estimator, b))
write_progress((i + 1) / n_images)
# display each block stats
plt.figure(figsize=(25, 20))
plt.rc('xtick', labelsize=22) # fontsize of the tick labels
plt.rc('ytick', labelsize=22) # fontsize of the tick labels
for i, zone in enumerate(zones):
plt.plot(zone, linewidth=3, label='zone ' + str(i))
plt.title('Estimator evolution on zones for ' + scene, fontsize=30)
plt.legend(fontsize=20)
plt.xlabel('Number of images', fontsize=28)
plt.ylabel(p_estimator + ' evolution during rendering', fontsize=28)
if len(p_y_lim) > 0:
p_x, p_y = list(map(int, p_y_lim.split(',')))
plt.ylim((p_x, p_y))
output_folder = os.path.join(figures_output, p_output)
if not os.path.exists(output_folder):
os.makedirs(output_folder)
plt.savefig(
os.path.join(output_folder, p_estimator + '_' + scene +
'.png')) #, transparent=True)
print()
def main():
p_custom = False
parser = argparse.ArgumentParser(
description="Script which predicts threshold using specific model")
parser.add_argument('--interval',
type=str,
help='Interval value to keep from svd',
default='"0, 200"')
parser.add_argument('--model',
type=str,
help='.joblib or .json file (sklearn or keras model)')
parser.add_argument('--mode',
type=str,
help='Kind of normalization level wished',
choices=normalization_choices)
parser.add_argument('--feature',
type=str,
help='Feature data choice',
choices=features_choices)
parser.add_argument(
'--limit_detection',
type=int,
help='Specify number of same prediction to stop threshold prediction',
default=2)
parser.add_argument(
'--custom',
type=str,
help='Name of custom min max file if use of renormalization of data',
default=False)
args = parser.parse_args()
p_interval = list(map(int, args.interval.split(',')))
p_model_file = args.model
p_mode = args.mode
p_feature = args.feature
p_limit = args.limit
p_custom = args.custom
scenes = os.listdir(scenes_path)
scenes = [s for s in scenes if not min_max_filename in s]
# go ahead each scenes
for id_scene, folder_scene in enumerate(scenes):
print(folder_scene)
scene_path = os.path.join(scenes_path, folder_scene)
threshold_expes = []
threshold_expes_detected = []
threshold_expes_counter = []
threshold_expes_found = []
# get all images of folder
scene_images = sorted([
os.path.join(scene_path, img) for img in os.listdir(scene_path)
if cfg.scene_image_extension in img
])
start_quality_image = dt.get_scene_image_quality(scene_images[0])
end_quality_image = dt.get_scene_image_quality(scene_images[-1])
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
zone_folder = "zone" + index_str
threshold_path_file = os.path.join(
os.path.join(scene_path, zone_folder), threshold_expe_filename)
with open(threshold_path_file) as f:
threshold = int(f.readline())
threshold_expes.append(threshold)
# Initialize default data to get detected model threshold found
threshold_expes_detected.append(False)
threshold_expes_counter.append(0)
threshold_expes_found.append(
end_quality_image) # by default use max
check_all_done = False
# for each images
for img_path in scene_images:
current_img = Image.open(img_path)
current_quality_image = dt.get_scene_image_quality(img_path)
current_image_potfix = dt.get_scene_image_postfix(img_path)
img_blocks = segmentation.divide_in_blocks(current_img, (200, 200))
current_img = Image.open(img_path)
img_blocks = segmentation.divide_in_blocks(current_img, (200, 200))
check_all_done = all(d == True for d in threshold_expes_detected)
if check_all_done:
break
for id_block, block in enumerate(img_blocks):
# check only if necessary for this scene (not already detected)
if not threshold_expes_detected[id_block]:
tmp_file_path = tmp_filename.replace(
'__model__',
p_model_file.split('/')[-1].replace('.joblib', '_'))
block.save(tmp_file_path)
python_cmd = "python prediction/predict_noisy_image_svd.py --image " + tmp_file_path + \
" --interval '" + p_interval + \
"' --model " + p_model_file + \
" --mode " + p_mode + \
" --feature " + p_feature
# specify use of custom file for min max normalization
if p_custom:
python_cmd = python_cmd + ' --custom ' + p_custom
## call command ##
p = subprocess.Popen(python_cmd,
stdout=subprocess.PIPE,
shell=True)
(output, err) = p.communicate()
## Wait for result ##
p_status = p.wait()
prediction = int(output)
if prediction == 0:
threshold_expes_counter[
id_block] = threshold_expes_counter[id_block] + 1
else:
threshold_expes_counter[id_block] = 0
if threshold_expes_counter[id_block] == p_limit:
threshold_expes_detected[id_block] = True
threshold_expes_found[id_block] = current_quality_image
print(
str(id_block) + " : " + current_image_potfix + "/" +
str(threshold_expes[id_block]) + " => " +
str(prediction))
print("------------------------")
print("Scene " + str(id_scene + 1) + "/" + str(len(scenes)))
print("------------------------")
# end of scene => display of results
# construct path using model name for saving threshold map folder
model_treshold_path = os.path.join(
threshold_map_folder,
p_model_file.split('/')[-1].replace('.joblib', ''))
# create threshold model path if necessary
if not os.path.exists(model_treshold_path):
os.makedirs(model_treshold_path)
abs_dist = []
map_filename = os.path.join(model_treshold_path,
threshold_map_file_prefix + folder_scene)
f_map = open(map_filename, 'w')
line_information = ""
# default header
f_map.write('| | | | |\n')
f_map.write('---|----|----|---\n')
for id, threshold in enumerate(threshold_expes_found):
line_information += str(threshold) + " / " + str(
threshold_expes[id]) + " | "
abs_dist.append(abs(threshold - threshold_expes[id]))
if (id + 1) % 4 == 0:
f_map.write(line_information + '\n')
line_information = ""
f_map.write(line_information + '\n')
min_abs_dist = min(abs_dist)
max_abs_dist = max(abs_dist)
avg_abs_dist = sum(abs_dist) / len(abs_dist)
f_map.write('\nScene information : ')
f_map.write('\n- BEGIN : ' + str(start_quality_image))
f_map.write('\n- END : ' + str(end_quality_image))
f_map.write('\n\nDistances information : ')
f_map.write('\n- MIN : ' + str(min_abs_dist))
f_map.write('\n- MAX : ' + str(max_abs_dist))
f_map.write('\n- AVG : ' + str(avg_abs_dist))
f_map.write('\n\nOther information : ')
f_map.write('\n- Detection limit : ' + str(p_limit))
# by default print last line
f_map.close()
print("Scene " + str(id_scene + 1) + "/" + str(len(scenes)) +
" Done..")
print("------------------------")
def generate_data_feature(path, output, human_thresholds, data_type, mode):
"""
@brief Method which generates all .csv files from scenes
@param data_type, feature choice
@param mode, normalization choice
@return nothing
"""
scenes = os.listdir(path)
# remove min max file from scenes folder
scenes = [s for s in scenes if min_max_filename not in s]
# keep in memory min and max data found from data_type
min_val_found = sys.maxsize
max_val_found = 0
output_path = os.path.join(cfg.output_data_generated, output)
if not os.path.exists(output_path):
os.makedirs(output_path)
data_min_max_filename = os.path.join(output_path, data_type + min_max_filename)
# go ahead each scenes
for folder_scene in human_thresholds:
print(folder_scene)
scene_path = os.path.join(path, folder_scene)
output_scene_path = os.path.join(output_path, folder_scene)
if not os.path.exists(output_scene_path):
os.makedirs(output_scene_path)
# getting output filename
output_svd_filename = data_type + "_" + mode + generic_output_file_svd
# construct each zones folder name
zones_folder = []
svd_output_files = []
# get zones list info
for index in zones:
index_str = str(index)
if len(index_str) < 2:
index_str = "0" + index_str
current_zone = "zone"+index_str
zones_folder.append(current_zone)
zone_path = os.path.join(scene_path, current_zone)
output_zone_path = os.path.join(output_scene_path, current_zone)
if not os.path.exists(output_zone_path):
os.makedirs(output_zone_path)
svd_file_path = os.path.join(output_zone_path, output_svd_filename)
# add writer into list
svd_output_files.append(open(svd_file_path, 'w'))
# get all images of folder
scene_images = sorted([os.path.join(scene_path, img) for img in os.listdir(scene_path) if cfg.scene_image_extension in img])
number_scene_image = len(scene_images)
for id_img, img_path in enumerate(scene_images):
current_image_postfix = dt.get_scene_image_postfix(img_path)
current_img = Image.open(img_path)
img_blocks = segmentation.divide_in_blocks(current_img, (200, 200))
for id_block, block in enumerate(img_blocks):
###########################
# feature computation part #
###########################
data = get_image_features(data_type, block)
##################
# Data mode part #
##################
# modify data depending mode
if mode == 'svdne':
# getting max and min information from min_max_filename
with open(data_min_max_filename, 'r') as f:
min_val = float(f.readline())
max_val = float(f.readline())
data = utils.normalize_arr_with_range(data, min_val, max_val)
if mode == 'svdn':
data = utils.normalize_arr(data)
# save min and max found from dataset in order to normalize data using whole data known
if mode == 'svd':
current_min = data.min()
current_max = data.max()
if current_min < min_val_found:
min_val_found = current_min
if current_max > max_val_found:
max_val_found = current_max
# now write data into current writer
current_file = svd_output_files[id_block]
# add of index
current_file.write(current_image_postfix + ';')
for val in data:
current_file.write(str(val) + ";")
current_file.write('\n')
print(data_type + "_" + mode + "_" + folder_scene + " - " + "{0:.2f}".format((id_img + 1) / number_scene_image * 100.) + "%")
sys.stdout.write("\033[F")
for f in svd_output_files:
f.close()
print('\n')
# save current information about min file found
if mode == 'svd':
with open(data_min_max_filename, 'w') as f:
f.write(str(min_val_found) + '\n')
f.write(str(max_val_found) + '\n')
print("%s_%s : end of data generation\n" % (data_type, mode))
