def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for origin_anno in annos: tiles = preprocess_image(deepcopy(origin_anno), H) for I, anno in tiles: if jitter: jitter_scale_min=0.9 jitter_scale_max=1.1 jitter_offset=16 I, anno = annotation_jitter(I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno) yield {"image": I, "boxes": boxes, "flags": flags}
def load_idl_tf(train_dir): image_height = 480 image_width = 640 grid_height = 15 grid_width = 20 rnn_len = 1 annotation = al.parse(train_dir) annos = [] for anno in annotation: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(train_dir)), anno.imageName) annos.append(anno) random.seed(0) for epoch in itertools.count(): random.shuffle(annos) for anno in annos: I = imread(anno.imageName) #Skip Greyscale images if len(I.shape) < 3: continue if I.shape[2] == 4: I = I[:, :, :3] boxes, flags = annotation_to_h5(anno, grid_width, grid_height, rnn_len) yield {"image": I, "boxes": boxes, "flags": flags}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for anno in annos: try: """ if 'grayscale' in H and 'grayscale_prob' in H: I = imread(anno.imageName, mode = 'RGB' if random.random() < H['grayscale_prob'] else 'L') if len(I.shape) < 3: I = cv2.cvtColor(I, cv2.COLOR_GRAY2RGB) else: if len(I.shape) < 3: continue I = imread(anno.imageName, mode = 'RGB') """ I = np.expand_dims(imread(anno.imageName, mode='L'), axis=2) #I = cv2.cvtColor(I, cv2.COLOR_GRAY2RGB) if I.shape[0] != H["image_height"] or I.shape[1] != H[ "image_width"]: if epoch == 0: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min = 0.9 jitter_scale_max = 1.1 jitter_offset = 16 I, anno = annotation_jitter( I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags} except Exception as exc: print(exc)
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" arch = H['arch'] annolist = al.parse(idlfile) annos = [x for x in annolist] for anno in annos: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] while True: random.shuffle(annos) for anno in annos: if arch["image_width"] != 640 or arch["image_height"] != 480: rescale_boxes(anno, arch["image_width"], arch["image_height"]) I = imread(anno.imageName) if jitter: jit_image, jit_anno = annotation_jitter( I, anno, target_width=arch["image_width"], target_height=arch["image_height"]) else: I = imread(anno.imageName) try: jit_image, jit_anno = annotation_jitter( I, anno, target_width=arch["image_width"], target_height=arch["image_height"], jitter_scale_min=1.0, jitter_scale_max=1.0, jitter_offset=0) except: import traceback print(traceback.format_exc()) continue boxes, box_flags = annotation_to_h5(jit_anno, arch["grid_width"], arch["grid_height"], arch["rnn_len"]) yield { "imname": anno.imageName, "raw": [], "image": jit_image, "boxes": boxes, "box_flags": box_flags }
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for anno in annos: I = imread(anno.imageName) #Skip Greyscale images #if len(I.shape) < 3: # continue #if I.shape[2] == 4: # I = I[:, :, :3] print anno.imageName #I = tf.reshape(I, [I.shape[0], I.shape[1], 1]) if I.shape[0] != H["image_height"] or I.shape[1] != H[ "image_width"]: if epoch == 0: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min = 0.9 jitter_scale_max = 1.1 jitter_offset = 16 I, anno = annotation_jitter(I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for anno in annos: I = imread(anno.imageName) #Skip Greyscale images if len(I.shape) < 3: continue if I.shape[2] == 4: I = I[:, :, :3] if I.shape[0] != H["image_height"] or I.shape[1] != H["image_width"]: if epoch == 0: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min=0.9 jitter_scale_max=1.1 jitter_offset=16 I, anno = annotation_jitter(I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags}
def prepare_annotations(images, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = create_annotation_list(images) annos = [] for anno in annolist: annos.append(anno) random.seed(0) for epoch in itertools.count(): random.shuffle(annos) for anno in annos: I = imread(anno.imageName) #Skip Greyscale images if len(I.shape) < 3: continue if I.shape[2] == 4: I = I[:, :, :3] if I.shape[0] != H["image_height"] or I.shape[1] != H[ "image_width"]: if epoch == 0: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min = 0.9 jitter_scale_max = 1.1 jitter_offset = 16 I, anno = annotation_jitter(I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" arch = H['arch'] annolist = al.parse(idlfile) annos = [x for x in annolist] for anno in annos: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] while True: random.shuffle(annos) for anno in annos: if arch["image_width"] != 640 or arch["image_height"] != 480: rescale_boxes(anno, arch["image_width"], arch["image_height"]) I = imread(anno.imageName) if jitter: jit_image, jit_anno = annotation_jitter(I, anno, target_width=arch["image_width"], target_height=arch["image_height"]) else: I = imread(anno.imageName) try: jit_image, jit_anno = annotation_jitter(I, anno, target_width=arch["image_width"], target_height=arch["image_height"], jitter_scale_min=1.0, jitter_scale_max=1.0, jitter_offset=0) except: import traceback print(traceback.format_exc()) continue boxes, box_flags = annotation_to_h5( jit_anno, arch["grid_width"], arch["grid_height"], arch["rnn_len"]) yield {"imname": anno.imageName, "raw": [], "image": jit_image, "boxes": boxes, "box_flags": box_flags}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [x for x in annolist] for anno in annos: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] while True: random.shuffle(annos) for anno in annos: I = imread(anno.imageName) if I.shape[0] != H["arch"]["image_height"] or I.shape[1] != H["arch"]["image_width"]: I, anno = rescale_boxes(I, anno, H["arch"]["image_height"], H["arch"]["image_width"]) if jitter: jitter_scale_min=0.9 jitter_scale_max=1.1 jitter_offset=16 I, anno = annotation_jitter(I, anno, target_width=H["arch"]["image_width"], target_height=H["arch"]["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(anno, H["arch"]["grid_width"], H["arch"]["grid_height"], H["arch"]["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse(idlfile) annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for anno in annos: I = imread(anno.imageName) dir_path = os.path.dirname(anno.imageName) file_name = anno.imageName.split('/')[-1] (shotname, extension) = os.path.splitext(file_name) p1_image_path = dir_path + "/" + (str(int(shotname) - 1)).zfill(4) + ".png" p2_image_path = dir_path + "/" + (str(int(shotname) - 2)).zfill(4) + ".png" p3_image_path = dir_path + "/" + (str(int(shotname) - 3)).zfill(4) + ".png" p4_image_path = dir_path + "/" + (str(int(shotname) - 4)).zfill(4) + ".png" p5_image_path = dir_path + "/" + (str(int(shotname) - 5)).zfill(4) + ".png" p6_image_path = dir_path + "/" + (str(int(shotname) - 6)).zfill(4) + ".png" p7_image_path = dir_path + "/" + (str(int(shotname) - 7)).zfill(4) + ".png" p8_image_path = dir_path + "/" + (str(int(shotname) - 8)).zfill(4) + ".png" f_image_path = dir_path + "/" + (str(int(shotname) + 1)).zfill(4) + ".png" if not os.path.exists(p1_image_path): print "File not exists: %s" % p1_image_path exit() if not os.path.exists(p2_image_path): print "File not exists: %s" % p2_image_path exit() if not os.path.exists(p3_image_path): print "File not exists: %s" % p3_image_path exit() if not os.path.exists(p4_image_path): print "File not exists: %s" % p4_image_path exit() if not os.path.exists(p5_image_path): print "File not exists: %s" % p5_image_path exit() if not os.path.exists(p6_image_path): print "File not exists: %s" % p6_image_path exit() if not os.path.exists(p7_image_path): print "File not exists: %s" % p7_image_path exit() if not os.path.exists(p8_image_path): print "File not exists: %s" % p8_image_path exit() if not os.path.exists(f_image_path): print "File not exists: %s" % f_image_path exit() p1_I = imread(p1_image_path) p2_I = imread(p2_image_path) p3_I = imread(p3_image_path) p4_I = imread(p4_image_path) p5_I = imread(p5_image_path) p6_I = imread(p6_image_path) p7_I = imread(p7_image_path) p8_I = imread(p8_image_path) f_I = imread(f_image_path) #Skip Greyscale images if len(I.shape) < 3: continue if I.shape[2] == 4: I = I[:, :, :3] p1_I = p1_I[:, :, :3] p2_I = p2_I[:, :, :3] p3_I = p3_I[:, :, :3] p4_I = p4_I[:, :, :3] p5_I = p5_I[:, :, :3] p6_I = p6_I[:, :, :3] p7_I = p7_I[:, :, :3] p8_I = p8_I[:, :, :3] f_I = f_I[:, :, :3] if I.shape[0] != H["image_height"] or I.shape[1] != H["image_width"]: if epoch == 0: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') p1_I = imresize(p1_I, (H["image_height"], H["image_width"]), interp='cubic') p2_I = imresize(p2_I, (H["image_height"], H["image_width"]), interp='cubic') p3_I = imresize(p3_I, (H["image_height"], H["image_width"]), interp='cubic') p4_I = imresize(p4_I, (H["image_height"], H["image_width"]), interp='cubic') p5_I = imresize(p5_I, (H["image_height"], H["image_width"]), interp='cubic') p6_I = imresize(p6_I, (H["image_height"], H["image_width"]), interp='cubic') p7_I = imresize(p7_I, (H["image_height"], H["image_width"]), interp='cubic') p8_I = imresize(p8_I, (H["image_height"], H["image_width"]), interp='cubic') f_I = imresize(f_I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min=0.9 jitter_scale_max=1.1 jitter_offset=16 I, anno = annotation_jitter(I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags, "p1_image": p1_I, "p2_image": p2_I, "p3_image": p3_I, "p4_image": p4_I, "p5_image": p5_I, "p6_image": p6_I, "p7_image": p7_I, "p8_image": p8_I, "f_image": f_I}
def load_idl_tf(idlfile, H, jitter): """Take the idlfile and net configuration and create a generator that outputs a jittered version of a random image from the annolist that is mean corrected.""" annolist = al.parse( idlfile, root_dir=H['data']['root_dir'] if 'root_dir' in H['data'] else './') augmenter = Augmentation() annos = [] for anno in annolist: anno.imageName = os.path.join( os.path.dirname(os.path.realpath(idlfile)), anno.imageName) annos.append(anno) random.seed(0) if H['data']['truncate_data']: annos = annos[:10] for epoch in itertools.count(): random.shuffle(annos) for anno in annos: try: if 'grayscale' in H and 'grayscale_prob' in H: I = imread(anno.imageName, mode='RGB' if random.random() < H['grayscale_prob'] else 'L') if len(I.shape) < 3: I = cv2.cvtColor(I, cv2.COLOR_GRAY2RGB) else: if len(I.shape) < 3: continue I = imread(anno.imageName, mode='RGB') labels = np.array([[r.x1, r.y1, r.x2, r.y2] for r in anno.rects]) if len(labels) == 0: labels = np.zeros((0, 4)) I, labels, _ = augmenter(I, labels, np.zeros((len(labels), 1))) new_rects = [] for box in labels: r = al.AnnoRect() r.x1, r.y1, r.x2, r.y2 = box new_rects.append(r) new_anno = al.Annotation() new_anno.imageName = anno.imageName new_anno.imagePath = anno.imagePath new_anno.rects = new_rects anno = new_anno # img = I[:, :, (2,1,0)].copy() # for r in anno.rects: # cv2.rectangle(img, tuple(map(int, (r.x1, r.y1))), tuple(map(int, (r.x2, r.y2))), (0,0,255)) # cv2.imwrite('test.jpg', img) # pdb.set_trace() if I.shape[0] != H["image_height"] or I.shape[1] != H[ "image_width"]: anno = rescale_boxes(I.shape, anno, H["image_height"], H["image_width"]) I = imresize(I, (H["image_height"], H["image_width"]), interp='cubic') if jitter: jitter_scale_min = 0.9 jitter_scale_max = 1.1 jitter_offset = 16 I, anno = annotation_jitter( I, anno, target_width=H["image_width"], target_height=H["image_height"], jitter_scale_min=jitter_scale_min, jitter_scale_max=jitter_scale_max, jitter_offset=jitter_offset) boxes, flags = annotation_to_h5(H, anno, H["grid_width"], H["grid_height"], H["rnn_len"]) yield {"image": I, "boxes": boxes, "flags": flags} except Exception as exc: print(exc)