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)
