def get_results():
test_lab = np.zeros((test.shape[0], 128, 128, 3))
train_lab = np.zeros((test.shape[0], 128, 128, 3))
for i, image in enumerate(train[:75]):
train_lab[i] = rgb_to_lab(image)
for i, image in enumerate(test):
test_lab[i] = rgb_to_lab(image)
Xtrain_lab = train_lab[:, :, :, :1]
Ytrain_lab = train_lab[:, :, :, 1:]
Xtest_lab = test_lab[:, :, :, :1]
Ytest_lab = test_lab[:, :, :, 1:]
print("Loss on test set of 75 images")
print(model.evaluate(Xtest_lab, Ytest_lab))
predict(Xtest_lab, 'test')
predict(Xtrain_lab, 'train')
def predict(self, path):
rgb = img_to_array(load_img(path, target_size=settings.SIZE)).astype(np.uint8) # shape (224, 224, 3)
x_lab = [rgb_to_lab(rgb)]
lab = np.stack(x_lab) # shape (1, 224, 224, 3)
l = lab[:, :, :, 0:1] # shape (1, 224, 224, 1)
preds = self.autoencoder.predict(l, verbose=0)
preds_lab = np.concatenate((l, preds), 3).astype(np.uint8)
preds_rgp = lab_to_rgb(preds_lab[0, :, :, :])
gray_image = img_to_array(ImageOps.grayscale(array_to_img(rgb)))
auto_colored_image = preds_rgp
np_img_list = [gray_image, auto_colored_image, rgb]
self.save(datetime.now().strftime('%Y%m%d%H%M%S'), np_img_list)
def get_results():
Xtest_lab = np.zeros((test.shape[0], 128, 128, 1))
Ytest_lab = np.zeros((test.shape[0], 2, 1))
for i, image in enumerate(test):
lab_image = rgb_to_lab(image.astype(np.uint8))
l, a, b = lab_image[:, :, :1], lab_image[:, :, 1:2], lab_image[:, :,
2:3]
Xtest_lab[i] = l
Ytest_lab[i, 0] = np.mean(a)
Ytest_lab[i, 1] = np.mean(b)
print("Loss on test set of 75 images",
model.evaluate(Xtest_lab, Ytest_lab))
predict(Xtest_lab, 'test')
def _manipulate_tone(self):
lab = utils.rgb_to_lab(self.img)
L = lab[..., 0]
L_mean = np.mean(L)
if self.sequence is None:
self.sequence = self.decompose(L)
lab = tone_manipulation(lab,
self.sequence,
self.a_values,
exposure=self.exposure,
saturation=self.saturation,
mask=self.mask)
return lab
def reader():
while True:
for data_path in data_paths:
raw_image = load_image(
file=data_path
) # raw_image has type: <type 'numpy.ndarray'>
# split raw_image to input and target according to a.which_direction
assert raw_image.shape[2] == 3
if lab_colorization:
# load color and brightness from image, no B image exists here
lab = utils.rgb_to_lab(raw_image)
L_chan, a_chan, b_chan = utils.preprocess_lab(lab)
a_image = L_chan # TODO:
b_image = np.stack([a_chan, b_chan], axis=2)
else:
# break apart image pair and move to range [-1, 1]
width = raw_image.shape[1] # [height, width, channels]
a_image = utils.preprocess(raw_image[:, :width // 2, :])
b_image = utils.preprocess(raw_image[:, width // 2:, :])
if which_direction == "AtoB":
input, target = [a_image, b_image]
elif which_direction == "BtoA":
input, target = [b_image, a_image]
else:
raise Exception("invalid direction")
input_image = simple_transform(im=input,
resize_size=resize_size,
crop_size=crop_size,
is_train=is_train)
target_image = simple_transform(im=target,
resize_size=resize_size,
crop_size=crop_size,
is_train=is_train)
# flip the images randomly
r = random.random()
if r > 0.5:
input_image = left_right_flip(input_image)
target_image = left_right_flip(target_image)
yield input_image, target_image
if not cycle:
break
def augment(batches, activation_last):
batch_num = 0
while True:
batch = next(batches)
augmented_batch = np.zeros((batch.shape[0], 128, 128, 3))
for i, image in enumerate(batch):
scalar = np.random.uniform(0.6, 1.0)
image = image * scalar
cv2.imwrite(
augmented_path + str(batch_num) + "_" + str(i) + ".jpg", image)
augmented_batch[i] = rgb_to_lab(image.astype(np.uint8))
batch_num += 1
X_batch = augmented_batch[:, :, :, :1]
if activation_last == 'relu':
Y_batch = augmented_batch[:, :, :, 1:]
else:
Y_batch = 2 * augmented_batch[:, :, :, 1:] - 1 # [0,1]->[-1,1]
yield (X_batch, Y_batch)
def augment(batches):
batch_num = 0
while True:
batch = next(batches)
X_batch = np.zeros((batch.shape[0], 128, 128, 1))
Y_batch = np.zeros((batch.shape[0], 2, 1))
for i, image in enumerate(batch):
scalar = np.random.uniform(0.6, 1.0)
image = image * scalar
cv2.imwrite(
augmented_path + str(batch_num) + "_" + str(i) + ".jpg", image)
lab_image = rgb_to_lab(image.astype(np.uint8))
l, a, b = lab_image[:, :, :1], lab_image[:, :,
1:2], lab_image[:, :, 2:3]
X_batch[i] = l
Y_batch[i, 0] = np.mean(a)
Y_batch[i, 1] = np.mean(b)
batch_num += 1
yield (X_batch, Y_batch)
def get_gray_and_ab(image: dict) -> Tuple[dict, tf.Tensor]:
"""
Get grayscale and ab channels from an rgb image
Parameters
----------
image: tf.Tensor
image in the LAB color space
Returns
-------
ab channels: tf.Tensor
"""
img = image['input_1']
gray = rgb_to_gray(img)
lab = rgb_to_lab(img)
ab = lab[:, :, 1:]
image['input_1'] = gray
image['input_2'] = gray
return image, ab
def get(self, query_string):
"""
query_string : string
5 colour input palette as hex format string
no #s, 5 colours of len 6, total len 30, no delimiters
eg 'bbafa557534d383530726b63958b81'
"""
query_palette = [query_string[i:i + 6] for i in range(0, 30, 6)]
rgb_palette = np.array(
[hex_to_rgb(colour) for colour in query_palette])
palette = rgb_to_lab(rgb_palette)
distances = (np.linalg.norm(all_possible_palettes - palette,
axis=3).sum(axis=2).min(axis=1))
palette_distances = pd.Series(dict(zip(image_ids, distances)))
most_similar_ids = (
palette_distances.sort_values()[1:13].index.values.tolist())
return jsonify({
'request': query_palette,
'response': ids_to_urls(most_similar_ids)
})
batch_input_1 = []
batch_input_2 = []
batch_l_channel = []
# prepare the input
for file in image_files[4:]:
img_contents = tf.io.read_file(file)
rgb = tf.image.decode_jpeg(img_contents)
# resize the image
input_1 = tf.image.resize_with_crop_or_pad(rgb,
target_width=224,
target_height=224)
input_2 = tf.image.resize_with_crop_or_pad(rgb,
target_width=229,
target_height=229)
# conver input_1 to lab
lab_img = rgb_to_lab(input_1)
l_channel = lab_img[:, :, 0]
batch_l_channel.append(l_channel)
# convert to grayscale
input_1 = tf.image.rgb_to_grayscale(input_1)
input_2 = tf.image.rgb_to_grayscale(input_2)
input_2 = tf.stack([input_2[:, :, 0]] * 3, axis=2)
# Normalize the image [-1, 1]
input_1 = normalize_rgb(input_1)
input_2 = normalize_rgb(input_2)
# add batch dimension
input_1 = tf.expand_dims(input_1, axis=0)
def get_lab_from_data_list(self, data_list):
x_lab = []
for f in data_list:
rgb = img_to_array(load_img(f, target_size=settings.SIZE)).astype(np.uint8)
x_lab.append(rgb_to_lab(rgb))
return np.stack(x_lab)