def get_scores(self, positive, negative):
scores = []
for array in [positive, negative]:
A_imgs = []
B_imgs = []
info = []
for (image_A_name, image_B_name, label) in tqdm(array.values):
img_A = load_image(image_A_name,
input_shape=self.input_shape,
mode='train')
img_B = load_image(image_B_name,
input_shape=self.input_shape,
mode='train')
A_imgs.append(img_A)
B_imgs.append(img_B)
info.append((image_A_name, image_B_name, label))
A_tensor = np.stack(A_imgs)
B_tensor = np.stack(B_imgs)
A_embedding = self.encoder.predict(A_tensor)
B_embedding = self.encoder.predict(B_tensor)
distances = cdist(A_embedding, B_embedding,
metric='euclidean').diagonal()
scores.extend(zip(distances, info))
positive_scores, negative_scores = scores[:len(positive)], scores[
len(positive):]
return positive_scores, negative_scores
def show_visualizations(self, scores, number_of_samples=None):
random.shuffle(scores)
counter = 0
for row in scores:
score, (image_A_name, image_B_name, label) = row
if number_of_samples is not None and counter >= number_of_samples:
break
img_A = load_image(image_A_name,
input_shape=self.input_shape,
mode='train')
img_B = load_image(image_B_name,
input_shape=self.input_shape,
mode='train')
heatmap_A = self.get_heatmap_encoder_learnt(img_A)
heatmap_B = self.get_heatmap_encoder_learnt(img_B)
plot_side_by_side(
[heatmap_A * 255, img_A, img_B, heatmap_B * 255],
titles=[
'heatmap B', image_A_name + "\nSCORE: {}".format(score),
image_B_name + "\nThe same? : {}".format(label),
'heatmap B'
])
counter += 1
def gen_img_pair_data(scene, pair_num, id_img2depth):
# for each scene, for each image, gen pair of images
K = np.loadtxt(DATA_PATH + scene + '/intrinsics.txt')
extrinsic_file = pd_util.preprocess_util.list_files(DATA_PATH + scene +
'/extrinsics/')
extrinsic_file.sort()
extrinsic = np.reshape(np.loadtxt(extrinsic_file[-1]), (-1, 3, 4))
# keep the original
id_img2depth = OrderedDict(sorted(id_img2depth.items(),
key=lambda t: t[0]))
image_names = id_img2depth.keys()
for i in range(0, len(image_names) - 30, 10):
pair_id = np.random.choice(range(10, 30), 10, replace=False)
for j in pair_id:
image_path1 = DATA_PATH + scene + '/image/' + image_names[
i] + '.jpg'
image_path2 = DATA_PATH + scene + '/image/' + image_names[
i + j] + '.jpg'
depth_path1 = DATA_PATH + scene + '/depth/' + id_img2depth[
image_names[i]] + '.png'
depth_path2 = DATA_PATH + scene + '/depth/' + id_img2depth[
image_names[i + j]] + '.png'
# try:
image1 = np.array(uts.load_image(image_path1))
image2 = np.array(uts.load_image(image_path2))
depth1 = uts.read_depth(depth_path1)
depth2 = uts.read_depth(depth_path2)
# except:
# continue
print "image1 name: {}, image2 name: {} \
depth1 name: {}, depth2 name: {}".format(
image_names[i], image_names[i + j],
id_img2depth[image_names[i]], id_img2depth[image_names[i + j]])
flow, is_valid = get_opt_flow(depth1, depth2, K,
extrinsic[i, :, :],
extrinsic[i + j, :, :], True, image1,
image2)
is_valid = False
uts.plot_images(
OrderedDict([('image1', image1), ('image2', image2),
('flowu', flow[:, :, 0]), ('flowv', flow[:, :,
1])]))
# print is_valid
if is_valid:
flow_file = FLOW_PATH + scene + '/flow/' + \
image_names[i] + '_' + image_names[i + j] + '.pkl'
print 'saving ' + flow_file
with open(flow_file, 'wb') as f:
pkl.dump(flow, f, -1)
def understand_blend():
inputs_path = os.path.join(os.path.dirname(__file__), 'data', 'input')
img1 = utils.load_image(os.path.join(inputs_path, 'figures.jpg'),
(500, 500))
img2 = utils.load_image(os.path.join(inputs_path, 'cloud.jpg'), (500, 500))
for alpha in np.arange(0, 1.2, 0.2):
blend = img1 + alpha * (
img2 - img1
) # This is how PIL's blend works simple linear interpolation
plt.imshow(blend)
plt.show()
def understand_blend():
img1 = utils.load_image(os.path.join(INPUT_DATA_PATH, 'figures.jpg'),
(500, 500))
img2 = utils.load_image(os.path.join(INPUT_DATA_PATH, 'cloud.jpg'),
(500, 500))
for alpha in np.arange(0, 1.2, 0.2):
blend = img1 + alpha * (
img2 - img1
) # This is how PIL's blend works simple linear interpolation
plt.imshow(blend)
plt.show()
def stylized_frames_mask_combiner(relevant_directories, dump_frame_extension, other_style=None):
# in dirs
frames_dir = relevant_directories['frames_path']
mask_frames_dir = relevant_directories['processed_masks_dump_path']
stylized_frames_dir = relevant_directories['stylized_frames_path']
# out dirs (we'll dump combined imagery here)
dump_path = os.path.join(stylized_frames_dir, os.path.pardir)
model_name_suffix = '_' + os.path.basename(os.path.split(other_style)[0]) if other_style is not None else ''
dump_path_bkg_masked = os.path.join(dump_path, 'composed_background_masked' + model_name_suffix)
dump_path_person_masked = os.path.join(dump_path, 'composed_person_masked' + model_name_suffix)
os.makedirs(dump_path_bkg_masked, exist_ok=True)
os.makedirs(dump_path_person_masked, exist_ok=True)
# if other_stylized_frames_path exists overlay frames are differently styled frames and not original frames
if other_style is not None:
overlay_frames_dir = other_style
else:
overlay_frames_dir = frames_dir
if len(os.listdir(dump_path_bkg_masked)) == 0 and len(os.listdir(dump_path_person_masked)) == 0:
for cnt, (name1, name2, name3) in enumerate(zip(sorted(os.listdir(stylized_frames_dir)), sorted(os.listdir(mask_frames_dir)), sorted(os.listdir(overlay_frames_dir)))):
s_img_path = os.path.join(stylized_frames_dir, name1) # stylized original frame image
m_img_path = os.path.join(mask_frames_dir, name2) # mask image
o_img_path = os.path.join(overlay_frames_dir, name3) # overlay image
# load input imagery
s_img = utils.load_image(s_img_path)
m_img = utils.load_image(m_img_path, target_shape=s_img.shape[:2])
o_img = utils.load_image(o_img_path, target_shape=s_img.shape[:2])
# prepare canvas imagery
combined_img_background = s_img.copy()
combined_img_person = s_img.copy()
# create masks
background_mask = m_img == 0.
person_mask = m_img == 1.
# apply masks
combined_img_background[background_mask] = o_img[background_mask]
combined_img_person[person_mask] = o_img[person_mask]
# save combined imagery
combined_img_background_path = os.path.join(dump_path_bkg_masked, str(cnt).zfill(FILE_NAME_NUM_DIGITS) + dump_frame_extension)
combined_img_person_path = os.path.join(dump_path_person_masked, str(cnt).zfill(FILE_NAME_NUM_DIGITS) + dump_frame_extension)
cv.imwrite(combined_img_background_path, (combined_img_background * 255).astype(np.uint8)[:, :, ::-1])
cv.imwrite(combined_img_person_path, (combined_img_person * 255).astype(np.uint8)[:, :, ::-1])
else:
print('Skipping combining with masks, already done.')
return {"dump_path_bkg_masked": dump_path_bkg_masked, "dump_path_person_masked": dump_path_person_masked}
def __init__(self):
super(Base, self).__init__()
self.net = VGG().to(opt.device).eval()
self.content_image = load_image(opt.content_image_path).to(opt.device)
self.style_image = load_image(opt.style_image_path).to(opt.device)
self.out_image = self.content_image.clone().requires_grad_(True)
self.optimizer = optim.Adam([self.out_image], opt.learning_rate)
## Hyper Pramaters
self.alpha = opt.alpha
self.beta = opt.beta
self.model = {'basemodel': self.net}
self.visual_names = ['total_loss']
def getCk(in_dir, label_dir, csv_file):
classes = get_classes(csv_file)
input_images = sorted(os.listdir(in_dir))
height, width, _ = utils.load_image(in_dir + "/" + input_images[0]).shape
#height = 2
#width = 2
for k in range(len(classes)):
cnt = np.zeros((height, width))
class_representative = np.zeros((height, width, 3))
for f in input_images:
print("Reading " + f)
image_path = in_dir + "/" + f
label_path = label_dir + "/" + f
image = cv2.imread(image_path, -1)
label = cv2.imread(label_path, -1)
#print(label)
for h in range(height):
for w in range(width):
if label[h, w, 2] == k:
class_representative[h, w] += image[h, w]
cnt[h, w] += 1
for h in range(height):
for w in range(width):
if cnt[h, w] > 0:
class_representative[
h, w] = class_representative[h, w] / cnt[h, w]
img = Image.fromarray(class_representative.astype(np.uint8))
img.save("C" + str(k) + ".png")
print("saved...")
def stylize(args):
img_list=os.listdir(args.content_image)
epoch_name=os.path.basename(args.model).split('.')[0]
experiment_name=os.path.dirname(args.output_image)
if not os.path.exists(experiment_name):
os.system('mkdir {}'.format(experiment_name))
if not os.path.exists(args.output_image):
os.system('mkdir {}'.format(args.output_image))
for img in img_list:
if is_image_file(img):
content_image = utils.load_image(os.path.join(args.content_image,img), scale=args.content_scale)
content_image=content_image.convert('RGB')
content_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: x.mul(255))
])
content_image = content_transform(content_image)
content_image = content_image.unsqueeze(0)
if args.cuda:
content_image = content_image.cuda()
content_image = Variable(content_image, volatile=True)
style_model = TransformerNet()
style_model.load_state_dict(torch.load(args.model))
if args.cuda:
style_model.cuda()
output = style_model(content_image)
if args.cuda:
output = output.cpu()
content_image=content_image.cpu()
output_data = output.data[0]
content_image_data=content_image.data[0]
output_data=torch.cat([content_image_data,output_data],2)
output_name=os.path.join(args.output_image,epoch_name+"_result_"+img)
utils.save_image(output_name, output_data)
def death_scene(self):
"""<Dr@m@tiK Sc3Ne>"""
position = self.get_current_position()
self.image = load_image("x_x.gif")
self.rect = self.image.get_rect()
self.rect[0], self.rect[1] = position
def get_embeddings(self):
all_unique_whales = pd.read_csv(
os.path.join(DATA_DIR, 'validation_all.csv'))
selected_whales_ids = all_unique_whales.groupby('Id')
selected_whales_ids_with_most_occurances = list(
selected_whales_ids.count().sort_values(
'Image', ascending=False)[:15].index)
selected_whales = all_unique_whales[all_unique_whales['Id'].isin(
selected_whales_ids_with_most_occurances)]
selected_whales = selected_whales[selected_whales['Id'] != 'new_whale']
imgs = []
classes = []
classes_names = {}
for image_name, class_name in selected_whales.values:
img = load_image(image_name,
input_shape=self.input_shape,
mode='train')
imgs.append(img)
if class_name not in classes_names.keys():
new_class = len(classes_names.keys()) + 1
classes_names[class_name] = new_class
classes.append(new_class)
else:
classes.append(classes_names[class_name])
if len(classes_names.keys()) == 20:
break
tensor = np.stack(imgs)
preprocessed_tensor = preprocess_input(tensor, self.model_name)
embeddings = self.encoder.predict(preprocessed_tensor)
return embeddings, np.array(classes), classes_names
def __data_generator(self, batch_samples):
# initialize images and labels tensors for faster processing
X = np.empty((len(batch_samples), *self.img_crop_dims, 3))
y = np.empty((len(batch_samples), self.n_classes))
for i, sample in enumerate(batch_samples):
# load and randomly augment image
img_file = os.path.join(
self.img_dir, '{}.{}'.format(sample['image_id'],
self.img_format))
img = utils.load_image(img_file, self.img_load_dims)
if img is not None:
img = utils.random_crop(img, self.img_crop_dims)
img = utils.random_horizontal_flip(img)
X[i, ] = img
# normalize labels
y[i, ] = utils.normalize_labels(sample['label'])
# apply basenet specific preprocessing
# input is 4D numpy array of RGB values within [0, 255]
X = self.basenet_preprocess(X)
return X, y
def deep_dream_video_ouroboros(config):
"""
Feeds the output dreamed image back to the input and repeat
Name etymology for nerds: https://en.wikipedia.org/wiki/Ouroboros
"""
ts = time.time()
assert any([config['input_name'].lower().endswith(img_ext) for img_ext in SUPPORTED_IMAGE_FORMATS]), \
f'Expected an image, but got {config["input_name"]}. Supported image formats {SUPPORTED_IMAGE_FORMATS}.'
utils.print_ouroboros_video_header(config) # print some ouroboros-related metadata to the console
img_path = utils.parse_input_file(config['input'])
# load numpy, [0, 1] range, channel-last, RGB image
# use_noise and consequently None value, will cause it to initialize the frame with uniform, [0, 1] range, noise
frame = None if config['use_noise'] else utils.load_image(img_path, target_shape=config['img_width'])
for frame_id in range(config['ouroboros_length']):
print(f'Ouroboros iteration {frame_id+1}.')
# Step 1: apply DeepDream and feed the last iteration's output to the input
frame = deep_dream_static_image(config, frame)
dump_path = utils.save_and_maybe_display_image(config, frame, name_modifier=frame_id)
print(f'Saved ouroboros frame to: {os.path.relpath(dump_path)}\n')
# Step 2: transform frame e.g. central zoom, spiral, etc.
# Note: this part makes amplifies the psychodelic-like appearance
frame = utils.transform_frame(config, frame)
video_utils.create_video_from_intermediate_results(config)
print(f'time elapsed = {time.time()-ts} seconds.')
def __init__(self,
image_path,
mask_path,
low_threshold,
high_threshold,
image_shape=(224, 224, 3),
augment=True):
self.image_path = image_path
self.mask_path = mask_path
self.low_threshold = np.log2(low_threshold)
self.high_threshold = np.log2(high_threshold)
self.image_shape = image_shape
self.image = utils.load_image(self.image_path, image_shape)
self.mask = utils.clean_mask(
utils.load_image(self.mask_path, image_shape))
self.augment = augment
def crop_and_save(img_paths, height, width, directories, with_label=False):
with progressbar.ProgressBar(max_value=len(img_paths)) as bar:
for index, img_path in enumerate(img_paths):
img_path = str(img_path)
img = utils.load_image(img_path)
date_time = utils.get_date_from_metadata(img)
image_save_directory = directories[0] + date_time
if not os.path.exists(image_save_directory):
os.makedirs(image_save_directory)
image = np.asarray(img)
# if with_label:
# json_path =args.main_jsons+ name+".json"
# label_points = utils.list_from_dict(dict_from_json(json_path)[0]['Label']['cranberry'])
# mask = utils.mask_from_list(label_points,3648,4864)
# img_mask_pair = join_img_label(img,mask)
# # label_name = "/"+str(index) + "_" + date_time + "_label"
# label_save_direcotry = directories[1] + date_time+"_label"
# cropped,cropped_label = utils.crop_and_save_single(image,height,width,with_label=True)
# else:
cropped = utils.crop_and_save_single(image,
height,
width,
image_save_directory,
str(index) + "_" + date_time,
with_label=False)
bar.update(1)
def predict(self, file, is_base64=False):
start = time.time()
if is_base64:
image = image_from_base64(file)
else:
image = load_image(file)
cccd_result = self._predictcccd(image)
if cccd_result is not None and 'id' in cccd_result and 'full_name' in cccd_result:
return build_result(file, cccd_result, "CCCD", start)
else:
# print("check image is cmnd")
cmnd_result = self.predictcmnd(image)
if cmnd_result is not None and 'id' in cmnd_result:
return build_result(file, cmnd_result, "CMND", start)
else:
# print("Not detect image")
return {
# 'urlimg':"",
'idc': "",
'fullname': "",
'dob': "",
'sex': '',
# 'ethnicity': '',
'national': '',
'country': '',
'address': '',
'score': 0,
'typekyc': "None",
'totaltime': round(time.time() - start)
}
def compute_gram_style(self, size):
style = utils.load_image(self.style_image_path, size=size)
style = self.style_transform(style)
style = style.repeat(self.opt.batch_size, 1, 1, 1).to(self.device)
features_style = self.vgg.get_features(style, 'style')
gram_style = [self.gram_matrix(y) for y in features_style['style']]
return gram_style
def deep_dream_video(config):
video_path = os.path.join(config['inputs_path'], config['input'])
tmp_input_dir = os.path.join(config['out_videos_path'], 'tmp_input')
tmp_output_dir = os.path.join(config['out_videos_path'], 'tmp_out')
config['dump_dir'] = tmp_output_dir
os.makedirs(tmp_input_dir, exist_ok=True)
os.makedirs(tmp_output_dir, exist_ok=True)
metadata = video_utils.dump_frames(video_path, tmp_input_dir)
last_img = None
for frame_id, frame_name in enumerate(sorted(os.listdir(tmp_input_dir))):
print(f'Processing frame {frame_id}')
frame_path = os.path.join(tmp_input_dir, frame_name)
frame = utils.load_image(frame_path, target_shape=config['img_width'])
if config['blend'] is not None and last_img is not None:
# 1.0 - get only the current frame, 0.5 - combine with last dreamed frame and stabilize the video
frame = utils.linear_blend(last_img, frame, config['blend'])
dreamed_frame = deep_dream_static_image(config, frame)
last_img = dreamed_frame
utils.save_and_maybe_display_image(
config,
dreamed_frame,
should_display=config['should_display'],
name_modifier=frame_id)
video_utils.create_video_from_intermediate_results(config, metadata)
shutil.rmtree(tmp_input_dir) # remove tmp files
print(f'Deleted tmp frame dump directory {tmp_input_dir}.')
def death_scene(self):
"""Dramatic scene."""
position = self.get_current_position()
self.image = load_image("x_x.gif")
self.rect = self.image.get_rect()
self.rect[0], self.rect[1] = position
self.dead = True
def load_image(self, image_name, mode):
"""
Load image and convert to Numpy array with values between 0 and 1
:param image_name: String with image name for ALL_DIR directory
:param mode: String "train" or "test", depends on which folder take images from
:return: Numpy array with values between 0 and 1 with shape self.train_conf.input_shape
"""
return load_image(image_name, self.train_conf.input_shape, mode)
def load_feature_style(self):
image = load_image(os.path.join(self.style_dir, self.style_image_name), size=self.image_size)
image = transforms.Compose([
transforms.CenterCrop(min(image.size[0], image.size[1])),
transforms.Resize(self.image_size),
transforms.ToTensor(),
])(image)
image = image.repeat(self.batch_size, 1, 1, 1)
self.style_image = image.to(self.device)
def predict_folder(model, folder_path):
image_list = utils.recursive_find_images(args.image,
extensions=('.jpg', '.png',
'.jpeg'))
results = []
for image_path in image_list:
image = utils.load_image(image_path)
pred = predict_single_image(model, image_path)
results.append((image, pred))
return results
def test_model(self):
inputs = []
images = []
file_paths = list_files_in_directory('test_resources/*.jpg')
for file_path in file_paths:
image_array = load_image(file_path, False, target_size=(300, 300))
images.append(imread(file_path))
inputs.append(image_array)
inputs = np.asarray(inputs, dtype='float32')
inputs = preprocess_input(inputs)
predictions = self.model.predict(inputs, batch_size=1, verbose=1)
prior_box_manager = PriorBoxManager(self.prior_boxes,
box_scale_factors=[.1, .1, .2, .2])
results = prior_box_manager.detection_out(predictions)
for i, img in enumerate(images):
# Parse the outputs.
det_label = results[i][:, 0]
det_conf = results[i][:, 1]
det_xmin = results[i][:, 2]
det_ymin = results[i][:, 3]
det_xmax = results[i][:, 4]
det_ymax = results[i][:, 5]
# Get detections with confidence higher than 0.6.
top_indices = [i for i, conf in enumerate(det_conf) if conf >= 0.8]
top_conf = det_conf[top_indices]
top_label_indices = det_label[top_indices].tolist()
top_xmin = det_xmin[top_indices]
top_ymin = det_ymin[top_indices]
top_xmax = det_xmax[top_indices]
top_ymax = det_ymax[top_indices]
colors = plt.cm.hsv(np.linspace(0, 1, 21)).tolist()
plt.imshow(img / 255.)
currentAxis = plt.gca()
for i in range(top_conf.shape[0]):
xmin = int(round(top_xmin[i] * img.shape[1]))
ymin = int(round(top_ymin[i] * img.shape[0]))
xmax = int(round(top_xmax[i] * img.shape[1]))
ymax = int(round(top_ymax[i] * img.shape[0]))
score = top_conf[i]
label = int(top_label_indices[i])
#label_name = voc_classes[label - 1]
#label_name = self.class_names[label - 1]
label_name = self.class_names[label]
display_txt = '{:0.2f}, {}'.format(score, label_name)
coords = (xmin, ymin), xmax-xmin+1, ymax-ymin+1
color = colors[label]
currentAxis.add_patch(plt.Rectangle(*coords, fill=False, edgecolor=color, linewidth=2))
currentAxis.text(xmin, ymin, display_txt, bbox={'facecolor':color, 'alpha':0.5})
plt.show()
def deep_dream_static_image(config, img):
device = torch.device("cuda" if torch.cuda.is_available() else
"cpu") # checking whether you have a GPU
model = utils.fetch_and_prepare_model(config['model'],
config['pretrained_weights'], device)
try:
layer_ids_to_use = [
model.layer_names.index(layer_name)
for layer_name in config['layers_to_use']
]
except Exception as e: # making sure you set the correct layer name for this specific model
print('Invalid layer name!')
print(
f'Available layers for model {config["model"].name} are {model.layer_names}.'
)
exit(0)
if img is None: # load either image or start from pure noise image
img_path = os.path.join(config['inputs_path'], config['input'])
img = utils.load_image(img_path, target_shape=config['img_width']
) # load numpy, [0, 1], channel-last, RGB image
if config['use_noise']:
shape = img.shape
img = np.random.uniform(low=0.0, high=1.0,
size=shape).astype(np.float32)
img = utils.preprocess_numpy_img(img)
base_shape = img.shape[:-1] # save initial height and width
# Note: simply rescaling the whole result (and not only details, see original implementation) gave me better results
# Going from smaller to bigger resolution (from pyramid top to bottom)
for pyramid_level in range(config['pyramid_size']):
new_shape = utils.get_new_shape(config, base_shape, pyramid_level)
img = cv.resize(img, (new_shape[1], new_shape[0]))
input_tensor = utils.pytorch_input_adapter(img, device)
for iteration in range(config['num_gradient_ascent_iterations']):
h_shift, w_shift = np.random.randint(
-config['spatial_shift_size'],
config['spatial_shift_size'] + 1, 2)
input_tensor = utils.random_circular_spatial_shift(
input_tensor, h_shift, w_shift)
gradient_ascent(config, model, input_tensor, layer_ids_to_use,
iteration)
input_tensor = utils.random_circular_spatial_shift(
input_tensor, h_shift, w_shift, should_undo=True)
img = utils.pytorch_output_adapter(input_tensor)
return utils.post_process_numpy_image(img)
def save_evaluation_images(self, epoch, alpha=0, latest=False):
image_names = os.listdir(self.opt.evaluation_images_path)
for ind, image_path in enumerate(image_names):
eval_image = utils.load_image(os.path.join(self.opt.evaluation_images_path, image_path), scale=2)
eval_tensor = self.eval_transform(eval_image).to(self.device).expand(1, -1, -1, -1)
output_tensor = self.recover_tensor(self.forward(eval_tensor, alpha_0=alpha).squeeze(dim=0)).clamp(min=0.0, max=1).cpu()
if latest:
save_name = 'latest_img_%d_alpha_%.3f.jpeg' % (ind, alpha)
else:
save_name = 'epoch_%d_img_%d_alpha_%.3f.jpeg' % (epoch, ind, alpha)
save_path = os.path.join(self.opt.images_save_dir, save_name)
utils.save_tensor_as_image(save_path, output_tensor)
def calculate_MAP(self, model):
for test_key in self.test_keys:
image_path = self.path_prefix + test_key
image_array = load_image(image_path, False, self.image_size)
image_array = np.expand_dims(image_array, axis=0)
image_array = preprocess_images(image_array)
predicted_data = self.model.predict(image_array)
predicted_data = np.squeeze(predicted_data)
original_image_size = None
predicted_boxes = self._decode_predictions(predicted_data,
original_image_size)
ground_truth_box_data = self.ground_truth_data[test_key].copy()
def deep_dream_video_ouroboros(config):
img_path = os.path.join(config['inputs_path'], config['input'])
# load numpy, [0, 1], channel-last, RGB image, None will cause it to start from the uniform noise [0, 1] image
frame = None if config['use_noise'] else utils.load_image(img_path, target_shape=config['img_width'])
for frame_id in range(config['video_length']):
print(f'Dream iteration {frame_id+1}.')
frame = deep_dream_static_image(config, frame)
utils.save_and_maybe_display_image(config, frame, should_display=config['should_display'], name_modifier=frame_id)
frame = utils.transform_frame(config, frame) # transform frame e.g. central zoom, spiral, etc.
video_utils.create_video_from_intermediate_results(config)
def main(args):
model, input_shape = utils.load_model_get_shape(args.model)
print(f'Loaded model {args.model}')
if args.dataset is not None:
print('Running inference on validation dataset')
results = predict_dataset(model, args.dataset)
visualise_gt(results, args.save_images)
elif os.path.isdir(args.image):
results = predict_folder(model, args.image)
else:
image = utils.load_image(args.image)
results = predict_single_image(model, image)
def state(self, key, screen):
"""Keylogger"""
self.shield = False
self.rotate = False
if key[K_SPACE]:
if not self.shield_ok():
self.shield = False
elif self.shield_ok():
self.shield = True
self.rotate = True
if key[K_DOWN]:
if not self.rect.y > 369:
self.rect = self.rect.move(0, self.speed)
if key[K_UP]:
if not self.rect.y < 82:
self.rect = self.rect.move(0, -self.speed)
if key[K_RIGHT]:
self.image = load_image("unicorn.png")
copy_pos = self.get_current_position()
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = copy_pos
if not self.rect.x > 680:
self.rect = self.rect.move(self.speed, 0)
if key[K_LEFT]:
self.image = load_image("left_unicorn.png")
copy_pos = self.get_current_position()
self.rect = self.image.get_rect()
self.rect.x, self.rect.y = copy_pos
if not self.rect.x < 20:
self.rect = self.rect.move(-self.speed, 0)
def pull_image(self, index):
"""Returns the original image object at index in PIL form
Note: not using self.__getitem__(), as any transformations passed in
could mess up this functionality.
Argument:
index (int): index of img to show
Return:
PIL img
"""
img_id = self.ids[index]
img = load_image(self._imgpath / (img_id.stem + '.jpg'))
return img
def __data_generator(self, batch_samples):
# initialize images and labels tensors for faster processing
X = np.empty((len(batch_samples), *self.img_load_dims, 3))
y = np.empty((len(batch_samples), self.n_classes))
for i, sample in enumerate(batch_samples):
# load and randomly augment image
img_file = os.path.join(self.img_dir, '{}.{}'.format(sample['image_id'], self.img_format))
img = utils.load_image(img_file, self.img_load_dims)
if img is not None:
X[i, ] = img
# normalize labels
if sample.get('label') is not None:
y[i, ] = utils.normalize_labels(sample['label'])
# apply basenet specific preprocessing
# input is 4D numpy array of RGB values within [0, 255]
X = self.basenet_preprocess(X)
return X, y