def load_kernel(self) -> None:
""" Load the metadate before training. """
self.classes = set()
for i, row in self.df.iterrows():
try:
sample_id = row["sample_id"]
WBC_type = row["WBC_types"]
origin = row["origin"]
if origin == "A":
image_path = get_image_local_path(sample_id,
self.DIR_PATH_A)
image = read_image(image_path)
annotation_path = get_xml_local_path(
sample_id, self.DIR_PATH_A)
annotations, image_shape = load_xml(annotation_path)
masks, class_labels = convert_annotations(
annotations, image_shape)
class_labels = [
correct_class_label(l, WBC_type) for l in class_labels
]
elif origin == "B":
image_path = get_image_local_path_B(
sample_id, self.DIR_PATH_B)
image = read_image(image_path)
mask = read_image(
get_mask_local_path_B(sample_id, self.DIR_PATH_B))
masks = mask[..., 0:1]
class_labels = WBC_type
# print(class_labels)
if (len(class_labels) == 0):
print(f'Skip sample {sample_id}, no gt_objects')
continue
for class_label in class_labels:
self.classes.update({class_label})
self.add_image(
source=self.source,
origin=origin,
image_id=sample_id,
sub_class_label=WBC_type,
path=image_path,
image_size=image.shape,
)
except Exception as e:
print(f'EXCP: {e} during handling {sample_id}')
continue
for i, c in enumerate(list(self.class_names_preset[1:])):
self.add_class(self.source, i + 1, c)
self.prepare()
return
def flow(self, mode='train'):
while True:
keys = self._mangage_keys(mode)
inputs = []
targets = []
for key in keys:
image_path = self.path_prefix + key + self.suffix
image_array = read_image(image_path)
original_image_size = image_array.shape[:2]
box_data = self.ground_truth_data[key]
if mode == 'train' or mode == 'demo':
image_array, box_data = self.transform(
image_array, box_data)
assigned_data = self.box_manager.assign_boxes(box_data)
assigned_data = self._denormalize_box(assigned_data,
original_image_size)
images, classes = self._crop_bounding_boxes(
image_array, assigned_data)
inputs = inputs + images
targets = targets + classes
# batch size does not always correspond to the real batch
if len(targets) >= self.batch_size:
inputs = np.asarray(inputs)
targets = np.asarray(targets)
inputs, targets = self._shuffle_together(inputs, targets)
if mode == 'train' or mode == 'val':
inputs = preprocess_images(inputs)
yield self._wrap_in_dictionary(inputs, targets)
if mode == 'demo':
yield self._wrap_in_dictionary(inputs, targets)
inputs = []
targets = []
def load_kernel(self) -> None:
""" Load the metadate before training. """
self.classes = set()
for sample_id in tqdm(self.sample_ids):
try:
image_path = get_image_local_path(sample_id, self.DIR_PATH)
image = read_image(image_path)
annotation_path = get_json_local_path(sample_id, self.DIR_PATH)
with open(annotation_path) as f:
annotations = json.load(f)
if (len(annotations["objects"]) == 0):
print(f'Skip sample {sample_id}, no gt_objects')
continue
for obj in annotations["objects"]:
self.classes.update({obj["classTitle"]})
self.add_image(
source=self.source,
image_id=sample_id,
sub_class_label="ConstructionSite",
path=image_path,
image_size=image.shape,
)
except Exception as e:
print(f'EXCP: {e} during handling {sample_id}')
continue
for i, c in enumerate(list(self.class_names_preset[1:])):
self.add_class(self.source, i + 1, c)
self.prepare()
return
def predict(self):
try:
from tkinter.filedialog import askdirectory
from glob import glob
directory = askdirectory(title="select a directory")
fn_list = glob(directory + '/*.jpg')
except ImportError:
from glob import glob
fn_list = glob(self.cfg.test_img_path + '/*.jpg')
result = {k: 0 for k in self.dataset.classes}
t = time.time()
for fn in fn_list:
img = read_image(fn, size=(299, 299))
img = img.to(self.device)
self.model.eval()
output = self.model(img)
_, pred = torch.max(output, 1)
res = self.dataset.idx_to_class[pred.item()]
print("{} : {}".format(fn, res))
result[res] += 1
print("result : ", result)
print('process spend : {} sec for {} images'.format(
time.time() - t, len(fn_list)))
def load_image(self, image_id, zero_image=False):
""" Load the images during training. """
info = self.image_info[image_id]
image_id = info['id']
image_path = get_image_local_path(image_id, self.DIR_PATH)
image = read_image(image_path)
return image
def load_kernel(self) -> None:
""" Load the metadate before training. """
self.classes = set()
for sample_id in tqdm(self.sample_ids):
try:
image_path = get_image_local_path(sample_id, self.DIR_PATH)
image = read_image(image_path)
# print(f"image shape {image.shape}")
annotation_path = get_xml_local_path(sample_id, self.DIR_PATH)
annotations, image_shape = load_xml(annotation_path)
_, class_labels = convert_annotations(annotations, image_shape)
if (len(class_labels) == 0):
print(f'Skip sample {sample_id}, no gt_objects')
continue
for class_label in class_labels:
self.classes.update({class_label})
self.add_image(
source=self.source,
image_id=sample_id,
sub_class_label="BloodCell",
path=image_path,
image_size=image.shape,
)
except Exception as e:
print(f'EXCP: {e} during handling {sample_id}')
continue
for i, c in enumerate(list(self.class_names_preset[1:])):
self.add_class(self.source, i + 1, c)
self.prepare()
return
def generator(samples, batch_size=32):
num_samples = len(samples)
print(num_samples)
while 1: #to run the generator indefinitely, pumping the X, Y sets for the neural network
#shuffle the samples on each EPOCH
sklearn.utils.shuffle(samples)
for offset in range(0, num_samples, batch_size):
batch_samples = samples[offset:offset + batch_size]
labels = []
images = []
ages = []
genders = []
races = []
age = []
gender = []
race = []
for batch_sample in batch_samples:
path, a, g, r = batch_sample
name = os.path.split(batch_sample[0])[-1]
image = utils.read_image(path)
#print(image.shape)
if (a > 100):
continue
images.append(image)
age.append(a)
gender.append(abs(1 - g))
race.append(r)
ages = to_categorical(age, num_classes=101)
genders = to_categorical(gender, num_classes=2)
races = to_categorical(race, num_classes=5)
labels = [np.array(genders), np.array(ages), np.array(races)]
X_train = np.array(images)
yield X_train, labels
def __getitem__(self, i):
if not self.uniform:
if self.npy:
img = np.load(self.df.loc[i, 'img']).astype(np.float32)
else:
img = utils.read_image(self.df.loc[i, 'img'])
label = self.df.loc[i, 'label']
else:
if len(self.batch) == 0:
self.create_batch()
img_path, label = self.batch.pop(0)
if self.npy:
img = np.load(img_path).astype(np.float32)
else:
img = utils.read_image(img_path)
img = self.transforms(image=img)['image']
return img, label
def __getitem__(self, i):
img = utils.read_image(self.img_list[i])
if self.TTA == 'hflip':
img = img[:, ::-1, :].copy()
elif self.TTA == 'vflip':
img = img[::-1, :, :].copy()
img = self.transforms(image=img)['image']
#img /= 255.0
return os.path.basename(self.img_list[i]), img
def load_image(self, image_id, zero_image=False):
""" Load the images during training. """
info = self.image_info[image_id]
image_id = info['id']
origin = info['origin']
if origin == "A":
image_path = get_image_local_path(image_id, self.DIR_PATH_A)
elif origin == "B":
image_path = get_image_local_path_B(image_id, self.DIR_PATH_B)
image = read_image(image_path)
return image
def thread_function(input_image, width, height, out_path):
image = utils.read_image(input_image)
if resize_images is not None:
image = utils.resize_image(image, width, height)
# remove all backgrounds
if should_remove_backgrounds:
image = utils.remove_background(image)
utils.save_image(out_path, image)
def draw_normalized_box(self, box_coordinates, image_key=None, color='r'):
if len(box_coordinates.shape) == 1:
box_coordinates = np.expand_dims(box_coordinates, 0)
if image_key == None:
image_path = self.random_instance.choice(self.image_paths)
else:
image_path = self.image_prefix + image_key
image_array = read_image(image_path)
image_array = resize_image(image_array, self.image_size)
figure, axis = plt.subplots(1)
axis.imshow(image_array)
original_coordinates = self.denormalize_box(box_coordinates)
x_min = original_coordinates[:, 0]
y_min = original_coordinates[:, 1]
x_max = original_coordinates[:, 2]
y_max = original_coordinates[:, 3]
width = x_max - x_min
height = y_max - y_min
if box_coordinates.shape[1] > 4:
classes = box_coordinates[:, 4:]
classes_flag = True
else:
classes_flag = False
num_boxes = len(box_coordinates)
for box_arg in range(num_boxes):
x_min_box = x_min[box_arg]
y_min_box = y_min[box_arg]
box_width = width[box_arg]
box_height = height[box_arg]
x_text = x_min_box + (1 * box_width )
y_text = y_min_box #+ (1 * box_height )
rectangle = plt.Rectangle((x_min_box, y_min_box),
box_width, box_height,
linewidth=1, edgecolor=color, facecolor='none')
axis.add_patch(rectangle)
if self.classes_decoder != None and classes_flag:
box_class = classes[box_arg]
class_name = self.classes_decoder[np.argmax(box_class)]
axis.text(x_text, y_text, class_name, style='italic',
bbox={'facecolor':'red', 'alpha':0.5, 'pad':10})
plt.show()
def load_mask(self, image_id):
""" Load the masks during training. """
info = self.image_info[image_id]
image_id = info['id']
origin = info['origin']
WBC_type = info['sub_class_label']
if origin == "A":
mask_path = get_xml_local_path(image_id, self.DIR_PATH_A)
annotations, image_shape = load_xml(mask_path)
masks, class_labels = convert_annotations(annotations, image_shape)
class_labels = [
correct_class_label(l, WBC_type) for l in class_labels
]
elif origin == "B":
mask_path = get_mask_local_path_B(image_id, self.DIR_PATH_B)
mask = read_image(mask_path)
masks = mask[..., 0:1]
class_labels = info["sub_class_label"]
class_ids = np.array([self._get_id_of_class(c) for c in class_labels],
dtype=np.int32)
return masks, class_ids
def load_data(self, train_set):
"""generate a batch data"""
img_set = []
label_set = []
for i in range(self.batch_size):
if self.num + self.batch_size >= len(train_set):
pdata = train_set[len(train_set) - 1 - i]
random.shuffle(train_set)
else:
pdata = train_set[self.num + i]
img, label = pdata.split()
label = "000" + label + "000"
img_data = read_image("./data/picture/" + img + ".jpg")
# img_set.append("./data/picture/" + img + ".jpg")
img_set.append(img_data)
label_data = list(map(eval, list(label)))
# label_data = [10 * i for i in label_data]
label_set.append(label_data)
self.num += self.batch_size
img_set = np.stack(img_set, 0)
return img_set, label_set
def load_kernel(self) -> None:
""" Load the dataset before inference. """
self.classes = set()
for sample_id in tqdm(self.sample_ids):
try:
image_path = get_image_local_path(sample_id, self.DIR_PATH)
image = read_image(image_path)
self.add_image(
source=self.source,
image_id=sample_id,
sub_class_label="ConstructionSite",
path=image_path,
image_size=image.shape,
)
except Exception as e:
print(f'EXCP: {e} during handling {sample_id}')
continue
for i, c in enumerate(list(self.class_names_preset[1:])):
self.add_class(self.source, i + 1, c)
self.prepare()
return
def thread_function(input_image, width, height, out_path):
image = utils.read_image(input_image)
image = utils.resize_image(image, width, height)
utils.save_image(out_path, image)
) args = parser.parse_args() dev = "cuda" if torch.cuda.is_available() else "cpu" device = torch.device(dev) visualizer = KittiVisualizer() # define model model = BiSeNetV2(19) checkpoint = torch.load(args.weight_path, map_location=dev) model.load_state_dict(checkpoint['bisenetv2'], strict=False) model.eval() model.to(device) image = read_image(args.img_path) original = np.copy(image) image = preprocessing_kitti(image) # image = preprocessing_cityscapes(image) # inference pred = model(image) pred = postprocessing(pred) # coloring pred = visualizer.semantic_to_color(pred) # pred = np.stack([pred,pred,pred], axis=2).astype(np.uint8) # visualize & save total = visualizer.add_semantic_to_image(original, pred)
def test():
"""
Test(Zooming SloMo) - inference on set of input data or Vid4 data
"""
# set context and load the model
ctx = get_extension_context(args.context)
nn.set_default_context(ctx)
nn.load_parameters(args.model)
input_dir = args.input_dir
n_ot = 7
# list all input sequence folders containing input frames
inp_dir_list = sorted(glob.glob(input_dir + '/*'))
inp_dir_name_list = []
avg_psnr_l = []
avg_psnr_y_l = []
avg_ssim_y_l = []
sub_folder_name_l = []
save_folder = 'results'
# for each sub-folder
for inp_dir in inp_dir_list:
gt_tested_list = []
inp_dir_name = inp_dir.split('/')[-1]
sub_folder_name_l.append(inp_dir_name)
inp_dir_name_list.append(inp_dir_name)
save_inp_folder = osp.join(save_folder, inp_dir_name)
img_low_res_list = sorted(glob.glob(inp_dir + '/*'))
util.mkdirs(save_inp_folder)
imgs = util.read_seq_imgs_(inp_dir)
img_gt_l = []
if args.metrics:
replace_str = 'LR'
for img_gt_path in sorted(glob.glob(osp.join(inp_dir.replace(replace_str, 'HR'), '*'))):
img_gt_l.append(util.read_image(img_gt_path))
avg_psnr, avg_psnr_sum, cal_n = 0, 0, 0
avg_psnr_y, avg_psnr_sum_y = 0, 0
avg_ssim_y, avg_ssim_sum_y = 0, 0
skip = args.metrics
select_idx_list = util.test_index_generation(
skip, n_ot, len(img_low_res_list))
# process each image
for select_idxs in select_idx_list:
# get input images
select_idx = [select_idxs[0]]
gt_idx = select_idxs[1]
imgs_in = F.gather_nd(
imgs, indices=nn.Variable.from_numpy_array(select_idx))
imgs_in = F.reshape(x=imgs_in, shape=(1,) + imgs_in.shape)
output = zooming_slo_mo_network(imgs_in, args.only_slomo)
outputs = output[0]
outputs.forward(clear_buffer=True)
for idx, name_idx in enumerate(gt_idx):
if name_idx in gt_tested_list:
continue
gt_tested_list.append(name_idx)
output_f = outputs.d[idx, :, :, :]
output = util.tensor2img(output_f)
cv2.imwrite(osp.join(save_inp_folder,
'{:08d}.png'.format(name_idx + 1)), output)
print("Saving :", osp.join(save_inp_folder,
'{:08d}.png'.format(name_idx + 1)))
if args.metrics:
# calculate PSNR
output = output / 255.
ground_truth = np.copy(img_gt_l[name_idx])
cropped_output = output
cropped_gt = ground_truth
crt_psnr = util.calculate_psnr(
cropped_output * 255, cropped_gt * 255)
cropped_gt_y = util.bgr2ycbcr(cropped_gt, only_y=True)
cropped_output_y = util.bgr2ycbcr(
cropped_output, only_y=True)
crt_psnr_y = util.calculate_psnr(
cropped_output_y * 255, cropped_gt_y * 255)
crt_ssim_y = util.calculate_ssim(
cropped_output_y * 255, cropped_gt_y * 255)
avg_psnr_sum += crt_psnr
avg_psnr_sum_y += crt_psnr_y
avg_ssim_sum_y += crt_ssim_y
cal_n += 1
if args.metrics:
avg_psnr = avg_psnr_sum / cal_n
avg_psnr_y = avg_psnr_sum_y / cal_n
avg_ssim_y = avg_ssim_sum_y / cal_n
avg_psnr_l.append(avg_psnr)
avg_psnr_y_l.append(avg_psnr_y)
avg_ssim_y_l.append(avg_ssim_y)
if args.metrics:
print('################ Tidy Outputs ################')
for name, ssim, psnr_y in zip(sub_folder_name_l, avg_ssim_y_l, avg_psnr_y_l):
print(
'Folder {} - Average SSIM: {:.6f} PSNR-Y: {:.6f} dB. '.format(name, ssim, psnr_y))
print('################ Final Results ################')
print('Total Average SSIM: {:.6f} PSNR-Y: {:.6f} dB for {} clips. '.format(
sum(avg_ssim_y_l) / len(avg_ssim_y_l), sum(avg_psnr_y_l) /
len(avg_psnr_y_l),
len(inp_dir_list)))
import numpy as np
from ssd import SSD300
from utils.utils import read_image
from utils.utils import resize_image
from utils.utils import preprocess_image
model = SSD300()
weights_filename = '../trained_models/model_checkpoints/weights.hdf5'
model.load_weights(weights_filename)
image_size = model.input_shape[1:3]
image_filename = '../images/008745.jpg'
image_array = read_image(image_filename)
image_array = resize_image(image_array, image_size)
image_array = image_array.astype('float32')
image_array = np.expand_dims(image_array, 0)
image_array = preprocess_image(image_array)
predictions = model.predict([image_array])
predictions = np.squeeze(predictions)
predicted_classes = predictions[:, 4:]
best_classes = np.argmax(predicted_classes, axis=1)
positive_mask = best_classes != 0
assigned_encoded_boxes)
decoded_positive_boxes = assigned_decoded_boxes[positive_mask, 0:4]
#box_visualizer.draw_normalized_box(decoded_positive_boxes, random_key)
batch_size = 10
image_generator = ImageGenerator(ground_truth_data,
prior_box_manager,
batch_size,
image_shape[0:2],
train_keys,
validation_keys,
image_prefix,
vertical_flip_probability=0,
horizontal_flip_probability=0.5)
generated_data = next(image_generator.flow(mode='train'))
transformed_image = generated_data[0]['image_array']
transformed_image = next(
image_generator.flow(mode='train'))[0]['image_array']
transformed_image = np.squeeze(transformed_image[0]).astype('uint8')
original_image = read_image(image_prefix + train_keys[0])
original_image = resize_image(original_image, image_shape[0:2])
#plot_images(original_image, transformed_image)
import numpy as np
classes = generated_data[1]['classes']
encoded_boxes = generated_data[1]['encoded_box']
masks = classes[:, :, 0] != 1
assigned_classes = classes[masks]
assigned_boxes = encoded_boxes[masks]
print(assigned_classes[0])
import sys
from utils.sql_ops import Sqlite
from utils import utils
field = ["id","img_url"]
types = ["TEXT", "TEXT"]
primary = 'ID'
def insert_img(data):
chara = Sqlite("starlightRe.db")
chara.create("img", field, types, primary)
chara.insert("img", data)
chara.close()
if __name__ == "__main__":
data = utils.read_image(sys.argv[1])
# data = read_file(sys.argv[1])
insert_img(data)
data_path = '../datasets/VOCdevkit/VOC2007/'
ground_truths = XMLParser(data_path + 'Annotations/').get_data()
prior_box_manager = PriorBoxAssigner(prior_boxes, ground_truths)
assigned_boxes = prior_box_manager.assign_boxes()
prior_box_manager.draw_assigned_boxes(image_path, image_shape[0:2], image_key)
batch_size = 7
train_keys, validation_keys = split_data(assigned_boxes, training_ratio=.8)
assigned_image_generator = ImageGenerator(assigned_boxes, batch_size,
image_shape[0:2], train_keys,
validation_keys,
data_path + 'JPEGImages/')
transformed_image = next(assigned_image_generator.flow(mode='demo'))[0]
transformed_image = np.squeeze(transformed_image[0]).astype('uint8')
original_image = read_image(data_path + 'JPEGImages/' + validation_keys[0])
original_image = resize_image(original_image, image_shape[0:2])
plt.figure(1)
plt.subplot(121)
plt.title('Original image')
plt.imshow(original_image)
plt.subplot(122)
plt.title('Transformed image')
plt.imshow(transformed_image)
plt.show()
box_transfomer = BoxTransformer(assigned_boxes, ground_truths)
encoded_boxes = box_transfomer.encode_boxes()
image_generator = ImageGenerator(encoded_boxes, batch_size, image_shape[0:2],
train_keys, validation_keys,
box_visualizer.draw_normalized_box(decoded_positive_boxes, selected_key)
# drawing generator output
train_keys, validation_keys = split_data(ground_truth_data, training_ratio=.8)
image_generator = ImageGenerator(ground_truth_data,
prior_box_manager,
1,
image_shape,
train_keys,
validation_keys,
image_prefix,
vertical_flip_probability=0,
horizontal_flip_probability=0.5)
generated_data = next(image_generator.flow(mode='demo'))
generated_input = generated_data[0]['input_1']
generated_output = generated_data[1]['predictions']
transformed_image = np.squeeze(generated_input[0]).astype('uint8')
validation_image_name = image_prefix + validation_keys[0]
original_image = read_image(validation_image_name)
original_image = resize_image(original_image, image_shape)
plot_images(original_image, transformed_image)
# finally draw the assigned boxes given by the generator
generated_encoded_boxes = np.squeeze(generated_output)
generated_boxes = prior_box_manager.decode_boxes(generated_encoded_boxes)
positive_mask = generated_boxes[:, 4] != 1
generated_positive_boxes = generated_boxes[positive_mask]
box_visualizer.draw_normalized_box(generated_positive_boxes,
validation_keys[0])
