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])