def save_soft_encode(path):
image = image_util.read_image(path)
lab = image_util.convert_rgb_to_lab(image)
se = image_util.soft_encode_lab_img(lab)
new_path = '../data/soft_encoded/' + path[-16:-5] + '_soft_encoded.npz'
np.savez_compressed(new_path, se)
return new_path
def test_weight_loss():
image = image_util.read_image('../test_images/fish.JPEG')
image = image_util.convert_rgb_to_lab(image)
image = image_util.soft_encode_lab_img(image)
print(image.shape)
with open('../probabilities/weights.pickle', 'rb') as fp:
weights = pickle.load(fp)
print("Shape", image.shape)
test = np.random.rand(64, 64, 262)
losses = 0
for h in range(image.shape[0]):
loss = np.dot(image[h],
np.log(test[h] + 0.000000000000000001).transpose())
loss = np.diag(loss)
loss = -loss
loss = np.sum(loss)
losses += loss
print(losses)
losses = 0
for h in range(test.shape[0]):
vs = np.array([weights[np.argmax(x)] for x in image[h]])
loss = vs[:, np.newaxis] * np.dot(
image[h],
np.log(test[h] + 0.000000000000000001).transpose())
loss = np.diag(loss)
loss = -loss
loss = np.sum(loss)
losses += loss
print(losses)
return losses
def save_input_output_2classes(path, newpath):
image = image_util.read_image(path)
lab = image_util.convert_rgb_to_lab(image)
se = image_util.soft_encode_lab_img(lab)
new_path = newpath
np.savez_compressed(new_path, input=lab, output=se)
def load_image_grey_in_softencode_out(image_path):
"""
Load an image, create the input and output of the network.
The input is a gray-scale image as a (width*height*1) numpy array
The output is a soft-encoding of the expected color bin as a
(width*height*num_bins) numpy array
:param image_path: the path to the image
:return: tuple of x and y (input and output)
"""
filename = os.path.split(image_path)[-1]
filename = os.path.splitext(filename)[0]
se_filename = os.path.join(c.soft_encoding_training_and_val_dir,
filename + c.soft_encoding_filename_postfix)
rgb = image_util.read_image(image_path)
cielab = image_util.convert_rgb_to_lab(rgb)
gray_channel = cielab[:, :, 0]
gray_channel = gray_channel[:, :, np.newaxis]
if os.path.exists(se_filename):
soft_encoding = np.load(se_filename)['arr_0']
else:
soft_encoding = image_util.soft_encode_lab_img(cielab)
return gray_channel, soft_encoding
def load_rgb_in_softencode_out(image_path):
path_split = os.path.split(image_path)
fn = path_split[1]
tag = fn.split("_")[0]
num = fn.split("_")[1]
rgb_save_path = os.path.join(
path_split[0],
"{}_{}_rgb.npz".format(tag, num)
)
if os.path.exists(rgb_save_path):
rgb = np.load(rgb_save_path)['arr_0']
else:
rgb = image_util.read_image(image_path)
filename = os.path.split(image_path)[-1]
filename = os.path.splitext(filename)[0]
se_filename = os.path.join(c.soft_encoding_training_and_val_dir,
filename + c.soft_encoding_filename_postfix)
if os.path.exists(se_filename):
soft_encoding = np.load(se_filename)['arr_0']
else:
cielab = image_util.convert_rgb_to_lab(rgb)
soft_encoding = image_util.soft_encode_lab_img(cielab)
return rgb, soft_encoding
def create_rgb_to_bin():
'''
Create a dictionary of all rgb colours to the corresponding bin size
'''
path_bins = '../np/bins.npz'
bins = np.load(path_bins)['arr_0']
n_bins = len(bins)
path_bincenters = '../np/bincenters.npz'
bincenters = np.load(path_bincenters)['arr_0']
rgb_to_bin = {}
for rall in range(256):
print(rall)
for gall in range(256):
for ball in range(256):
r = rall / 256
g = gall / 256
b = ball / 256
r = np.ones((1, 1)) * r
g = np.ones((1, 1)) * g
bb = np.ones((1, 1)) * b
rgb_pixel = np.stack((r, g, bb), axis=-1)
cie_pixel = image_util.convert_rgb_to_lab(rgb_pixel)
a = cie_pixel[:, :, 1].flatten()
b = cie_pixel[:, :, 2].flatten()
ab = np.stack((a, b), axis=-1)
d = np.zeros(n_bins)
for idx, c in enumerate(bincenters):
dist = np.linalg.norm(ab - c, axis=-1)
d[idx] = dist
bin = np.argmin(d)
r *= 256
g *= 256
bb *= 256
rgb_string = str(r[0][0]) + ', ' + str(g[0][0]) + ', ' + str(
bb[0][0])
print(rgb_string)
rgb_to_bin[rgb_string] = bin
def convert(image_paths, out_path):
'''
This functions creates tf record object.
Inputs are the paths to the rgb pictures. This functions saves
the different images in their cielab format and in their soft encoded format
:param image_path: Path to the images to convert into a tfrecord object
:param out_path: Path where to save the tfrecord object
:return:
'''
print("Converting: " + out_path)
# Number of images. Used when printing the progress.
num_images = len(image_paths)
# Open a TFRecordWriter for the output-file.
with tf.python_io.TFRecordWriter(out_path) as writer:
# Iterate over all the image-paths
for i, path in enumerate(image_paths):
if i % 1000 == 0:
print('Serialised ', i, 'files')
# Read the images
rgb = np.array(image_util.read_image(path))
cie = np.array(image_util.convert_rgb_to_lab(rgb))
se = np.array(image_util.soft_encode_lab_img(cie))
# Convert them into raw bytes
cie_bytes = cie.tostring()
se_bytes = se.tostring()
# Create a dict with the data saved in the record files
data = \
{
'cie': wrap_bytes(cie_bytes),
'label': wrap_bytes(se_bytes)
}
# Wrap the data as TensorFlow Features.
feature = tf.train.Features(feature=data)
# Wrap again as a TensorFlow Example.
example = tf.train.Example(features=feature)
# Serialize the data.
serialized = example.SerializeToString()
# Write the serialized data to the TFRecords file.
writer.write(serialized)
def on_train_begin(self, logs=None):
# create batch and store rgb and grey image
for idx, path in enumerate(self.image_paths):
rgb = image_util.read_image(path)
save_path = "img_{}_epoch_{}.png".format(idx, "0_ground_truth")
save_path = os.path.join(self.root_dir, save_path)
image_util.save_image(save_path, rgb)
grey = image_util.read_image(path, as_gray=True)
save_path = "img_{}_epoch_{}.png".format(idx, "0_grey")
save_path = os.path.join(self.root_dir, save_path)
image_util.save_image(save_path, grey)
lab = image_util.convert_rgb_to_lab(rgb)
grey = lab[:, :, 0:1]
self.batch[idx,] = grey
self.save_images('0_initial_prediction')
def load_image_grey_in_ab_out(image_path):
"""
Load an image, create the input and output of the network.
The input is a gray-scale image as a (width*height*1) numpy array
The output is a soft-encoding of the expected color bin as a
(width*height*num_bins) numpy array
:param image_path: the path to the image
:return: tuple of x and y (input and output)
"""
rgb = image_util.read_image(image_path)
cielab = image_util.convert_rgb_to_lab(rgb)
gray_channel = cielab[:, :, 0]
gray_channel = gray_channel[:, :, np.newaxis]
ab_channel = cielab[:, :, 1:]
return gray_channel, ab_channel
