def read_kitti_anno(label_file, detect_truck):
labels = [line.rstrip().split(' ') for line in open(label_file)]
rect_list = []
for label in labels:
#create the label of vehicles
if not (label[0] == 'Car' or label[0] == 'Van' or
label[0] == 'Truck' or label[0] == 'DontCare'):
continue
notruck = not detect_truck
if notruck and label[0] == 'Truck':
continue
if label[0] == 'DontCare':
class_id = -1
else:
class_id = 1
#create rectangle
object_rect = AnnoLib.AnnoRect(
x1=float(label[4]), y1=float(label[5]),
x2=float(label[6]), y2=float(label[7]))
#check the condition
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
#append to the list of the rresult
rect_list.append(object_rect)
def read_daimler_anno(label_file, detect_truck):
""" Reads a daimler cyclist annotation file.
Args:
label_file: Path to file
Returns:
Lists of rectangels: .
"""
label_data = json.load(open(label_file))
labels = [item for item in label_data['children']]
rect_list = []
for label in labels:
if not (label['identity'] == 'pedestrian' or label['identity']
== 'cyclist' or label['identity'] == 'wheelchairuser'
or label['identity'] == 'motorcyclist' or label['identity']
== 'tricyclist' or label['identity'] == 'mopedrider'):
continue
notruck = not detect_truck
if notruck and label['identity'] == 'Truck':
continue
if label['identity'] == 'DontCare':
class_id = -1
else:
class_id = 1
object_rect = AnnoLib.AnnoRect(x1=float(label['mincol']),
y1=float(label['minrow']),
x2=float(label['maxcol']),
y2=float(label['maxrow']))
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
rect_list.append(object_rect)
return rect_list
def add_rectangles(H,
orig_image,
confidences,
boxes,
use_stitching=False,
rnn_len=1,
min_conf=0.1,
show_removed=True,
tau=0.25,
show_suppressed=True):
image = np.copy(orig_image[0])
num_cells = H["grid_height"] * H["grid_width"]
boxes_r = np.reshape(boxes,
(-1, H["grid_height"], H["grid_width"], rnn_len, 4))
confidences_r = np.reshape(
confidences,
(-1, H["grid_height"], H["grid_width"], rnn_len, H['num_classes']))
cell_pix_size = H['region_size']
all_rects = [[[] for _ in range(H["grid_width"])]
for _ in range(H["grid_height"])]
for n in range(rnn_len):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
abs_cx = int(bbox[0]) + cell_pix_size / 2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size / 2 + cell_pix_size * y
w = bbox[2]
h = bbox[3]
conf = np.max(confidences_r[0, y, x, n, 1:])
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
all_rects_r = [r for row in all_rects for cell in row for r in cell]
if use_stitching:
from stitch_wrapper import stitch_rects
acc_rects = stitch_rects(all_rects, tau)
else:
acc_rects = all_rects_r
pairs = [(acc_rects, (0, 255, 0))]
if show_suppressed:
pairs.append((all_rects_r, (255, 0, 0)))
for rect_set, color in pairs:
for rect in rect_set:
if rect.confidence > min_conf:
cv2.rectangle(image, (rect.cx - int(rect.width / 2),
rect.cy - int(rect.height / 2)),
(rect.cx + int(rect.width / 2),
rect.cy + int(rect.height / 2)), color, 2)
rects = []
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
rects.append(r)
return image, rects
def read_kitti_anno(label_file):
""" Reads a kitti annotation file.
Args:
label_file: Path to file
Returns:
Lists of rectangels: Cars and don't care area.
"""
labels = [line.rstrip().split(' ') for line in open(label_file)]
rect_list = []
for label in labels:
if not (label[0] == 'Car' or label[0] == 'Van'
or label[0] == 'DontCare'):
continue
if label[0] == 'DontCare':
class_id = -1
else:
class_id = 1
object_rect = AnnoLib.AnnoRect(x1=float(label[4]),
y1=float(label[5]),
x2=float(label[6]),
y2=float(label[7]))
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
rect_list.append(object_rect)
return rect_list
def add_rectangles(H,
orig_image,
confidences,
boxes,
arch,
use_stitching=False,
rnn_len=1,
min_conf=0.5,
tau=0.25):
from utils.rect import Rect
from utils.stitch_wrapper import stitch_rects
import numpy as np
image = np.copy(orig_image[0])
boxes_r = np.reshape(
boxes, (-1, arch["grid_height"], arch["grid_width"], rnn_len, 4))
confidences_r = np.reshape(
confidences, (-1, arch["grid_height"], arch["grid_width"], rnn_len, 2))
cell_pix_size = H['arch']['region_size']
all_rects = [[[] for _ in range(arch["grid_width"])]
for _ in range(arch["grid_height"])]
for n in range(0, H['arch']['rnn_len']):
for y in range(arch["grid_height"]):
for x in range(arch["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
conf = confidences_r[0, y, x, n, 1]
abs_cx = int(bbox[0]) + cell_pix_size / 2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size / 2 + cell_pix_size * y
h = max(1, bbox[3])
w = max(1, bbox[2])
#w = h * 0.4
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
if use_stitching:
acc_rects = stitch_rects(all_rects, tau)
else:
acc_rects = [
r for row in all_rects for cell in row for r in cell
if r.confidence > 0.1
]
for rect in acc_rects:
if rect.confidence > min_conf:
cv2.rectangle(image, (rect.cx - int(rect.width / 2),
rect.cy - int(rect.height / 2)),
(rect.cx + int(rect.width / 2),
rect.cy + int(rect.height / 2)), (0, 255, 0), 2)
rects = []
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
rects.append(r)
return image, rects
def calculate_medium_box(boxes):
conf_sum = reduce(lambda t, b: t + b.score, boxes, 0)
aggregation = {}
for name in ['x1', 'y1', 'x2', 'y2']:
aggregation[name] = reduce(lambda t, b: t+b.__dict__[name]*b.score, boxes, 0) / conf_sum
new_box = al.AnnoRect(**aggregation)
new_box.classID = boxes[0].classID
new_box.score = conf_sum / len(boxes)
return new_box
def read_kitti_anno(label_file, calib_file, detect_truck):
""" Reads a kitti annotation file.
Args:
label_file: Path to file
Returns:
Lists of rectangels: Cars and don't care area.
"""
labels = [line.rstrip().split(' ') for line in open(label_file)]
label_file_split = label_file.rstrip().split('/')
index = label_file_split[-1].split('.')[0]
#import pdb
#pdb.set_trace()
calibs = [line.rstrip().split(' ') for line in open(calib_file)]
assert calibs[2][0] == 'P2:'
calib = np.reshape(calibs[2][1:], (3, 4)).astype(np.float32)
calib_pinv = np.linalg.pinv(calib)
rect_list = []
for label in labels:
if not (label[0] == 'Car' or label[0] == 'Van' or label[0] == 'Truck'
or label[0] == 'DontCare'):
continue
notruck = not detect_truck
if notruck and label[0] == 'Truck':
continue
if label[0] == 'DontCare':
class_id = -1
else:
class_id = 1
object_rect = AnnoLib.AnnoRect(x1=float(label[4]),
y1=float(label[5]),
x2=float(label[6]),
y2=float(label[7]),
height=float(label[8]),
width=float(label[9]),
length=float(label[10]),
x=float(label[11]),
y=float(label[12]),
z=float(label[13]),
alpha=float(label[14]),
calib=calib,
calib_pinv=calib_pinv)
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
view_angle = np.arctan2(object_rect.z_3d, object_rect.x_3d)
object_rect.alpha += view_angle - np.pi * 0.5
rect_list.append(object_rect)
return rect_list
def add_rectangles(orig_image,
confidences,
boxes,
arch,
use_stitching=False,
rnn_len=1,
min_conf=0.5):
image = np.copy(orig_image[0])
num_cells = arch["grid_height"] * arch["grid_width"]
boxes_r = np.reshape(
boxes, (-1, arch["grid_height"], arch["grid_width"], rnn_len, 4))
confidences_r = np.reshape(
confidences, (-1, arch["grid_height"], arch["grid_width"], rnn_len, 2))
cell_pix_size = 32
all_rects = [[[] for _ in range(arch["grid_width"])]
for _ in range(arch["grid_height"])]
for n in range(rnn_len):
for y in range(arch["grid_height"]):
for x in range(arch["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
conf = confidences_r[0, y, x, n, 1]
abs_cx = int(bbox[0]) + cell_pix_size / 2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size / 2 + cell_pix_size * y
w = bbox[2]
h = bbox[3]
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
if use_stitching:
from stitch_wrapper import stitch_rects
acc_rects = stitch_rects(all_rects)
else:
acc_rects = [r for row in all_rects for cell in row for r in cell]
for rect in acc_rects:
if rect.confidence > min_conf:
cv2.rectangle(image, (rect.cx - int(rect.width / 2),
rect.cy - int(rect.height / 2)),
(rect.cx + int(rect.width / 2),
rect.cy + int(rect.height / 2)), (0, 255, 0), 2)
rects = []
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
rects.append(r)
return image, rects
def get_multiclass_rectangles(H, confidences, boxes, rnn_len):
boxes_r = np.reshape(boxes, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
4))
confidences_r = np.reshape(confidences, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
H['num_classes']))
# print "boxes_r shape" + str(boxes_r.shape)
# print "confidences" + str(confidences.shape)
cell_pix_size = H['region_size']
all_rects = [[[] for _ in range(H["grid_width"])] for _ in range(H["grid_height"])]
for n in range(rnn_len):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
abs_cx = int(bbox[0]) + cell_pix_size/2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size/2 + cell_pix_size * y
w = bbox[2]
h = bbox[3]
# conf = np.max(confidences_r[0, y, x, n, 1:])
index, conf = get_silhouette_confidence(confidences_r[0, y, x, n, 1:])
# print index, conf
# print np.max(confidences_r[0, y, x, n, 1:])
# print "conf" + str(conf)
# print "conf" + str(confidences_r[0, y, x, n, 1:])
new_rect=multiclass_rectangle.Rectangle_Multiclass()
new_rect.set_unlabeled_rect(abs_cx,abs_cy,w,h,conf)
all_rects[y][x].append(new_rect)
# print "confidences_r" + str(confidences_r.shape)
all_rects_r = [r for row in all_rects for cell in row for r in cell]
min_conf = get_higher_confidence(all_rects_r)
acc_rects=[rect for rect in all_rects_r if rect.true_confidence>min_conf]
rects = []
for rect in all_rects_r:
if rect.true_confidence>min_conf:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width/2.
r.x2 = rect.cx + rect.width/2.
r.y1 = rect.cy - rect.height/2.
r.y2 = rect.cy + rect.height/2.
r.score = rect.true_confidence
r.silhouetteID=rect.label
rects.append(r)
print len(rects),len(acc_rects)
return rects, acc_rects
def get_cell_grid(cell_width, cell_height, region_size):
cell_regions = []
for iy in range(cell_height):
for ix in range(cell_width):
cidx = iy * cell_width + ix
ox = (ix + 0.5) * region_size
oy = (iy + 0.5) * region_size
r = al.AnnoRect(ox - 0.5 * region_size, oy - 0.5 * region_size,
ox + 0.5 * region_size, oy + 0.5 * region_size)
r.track_id = cidx
cell_regions.append(r)
return cell_regions
def read_kitti_anno(label_file, detect_truck):
""" Reads a kitti annotation file.
Args:
label_file: Path to file
Returns:
Lists of rectangels: Cars and don't care area.
"""
labels = [line.rstrip().split(' ') for line in open(label_file)]
rect_list = []
for label in labels:
if not (label[0] == 'Car' or label[0] == 'Van' or label[0] == 'Truck'
or label[0] == 'DontCare'):
continue
#notruck = not detect_truck
notruck = 0
if notruck and label[0] == 'Truck':
continue
if label[0] == 'DontCare':
class_id = -1
else:
class_id = 1
bbox = [
float(label[1]),
float(label[2]),
float(label[3]),
float(label[4])
]
if bbox[0] <= 0: bbox[0] = 3
if bbox[1] <= 0: bbox[1] = 2
if bbox[2] >= 1919: bbox[2] = 1916
if bbox[3] >= 1055: bbox[3] = 1053
object_rect = AnnoLib.AnnoRect(x1=float(bbox[0]),
y1=float(bbox[1]),
x2=float(bbox[2]),
y2=float(bbox[3]))
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
rect_list.append(object_rect)
return rect_list
def read_rects(file):
with open(file, 'r') as f:
lines = f.readlines()
rects = []
for line in lines:
# 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
# "Car 0 1 0 %f %f %f %f 0 0 0 0 0 0 0 %f"
split = line.split(' ')
# If not a car, don't care
if split[0] != 'Car':
continue
x1 = float(split[4])
y1 = float(split[5])
x2 = float(split[6])
y2 = float(split[7])
rect = AnnotationLib.AnnoRect(x1, y1, x2, y2)
rect.score = float(split[-1])
rects.append(rect)
return rects
def get_singleclass_rectangles(H, confidences, boxes, min_conf,rnn_len=1):
boxes_r = np.reshape(boxes, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
4))
confidences_r = np.reshape(confidences, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
2))
cell_pix_size = H['region_size']
all_rects = [[[] for _ in range(H["grid_width"])] for _ in range(H["grid_height"])]
for n in range(0, H['rnn_len']):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
conf = confidences_r[0, y, x, n, 1]
abs_cx = int(bbox[0]) + cell_pix_size/2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size/2 + cell_pix_size * y
h = max(1, bbox[3])
w = max(1, bbox[2])
#w = h * 0.4
all_rects[y][x].append(Rect(abs_cx,abs_cy,w,h,conf))
all_rects_r = [r for row in all_rects for cell in row for r in cell if r.true_confidence > min_conf]
rects = []
for rect in all_rects_r:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width/2.
r.x2 = rect.cx + rect.width/2.
r.y1 = rect.cy - rect.height/2.
r.y2 = rect.cy + rect.height/2.
r.score = rect.true_confidence
rects.append(r)
return rects
def pal2al(_annolist):
#annotations = [];
annotations = AnnotationLib.AnnoList();
for adesc in _annolist.attribute_desc:
annotations.attribute_desc[adesc.name] = adesc;
print("attribute: ", adesc.name, adesc.id)
for valdesc in adesc.val_to_str:
annotations.add_attribute_val(adesc.name, valdesc.s, valdesc.id);
attribute_name_from_id = {adesc.id: aname for aname, adesc in annotations.attribute_desc.iteritems()}
attribute_dtype_from_id = {adesc.id: adesc.dtype for aname, adesc in annotations.attribute_desc.iteritems()}
for _a in _annolist.annotation:
anno = AnnotationLib.Annotation()
anno.imageName = _a.imageName;
anno.rects = [];
for _r in _a.rect:
rect = AnnotationLib.AnnoRect()
rect.x1 = _r.x1;
rect.x2 = _r.x2;
rect.y1 = _r.y1;
rect.y2 = _r.y2;
if _r.HasField("id"):
rect.id = _r.id;
if _r.HasField("track_id"):
rect.track_id = _r.track_id;
if _r.HasField("score"):
rect.score = _r.score;
for _at in _r.attribute:
try:
cur_aname = attribute_name_from_id[_at.id];
cur_dtype = attribute_dtype_from_id[_at.id];
except KeyError as e:
print("attribute: ", _at.id)
print(e)
assert(False);
if cur_dtype == AnnotationLib.AnnoList.TYPE_INT32:
rect.at[cur_aname] = _at.val;
elif cur_dtype == AnnotationLib.AnnoList.TYPE_FLOAT:
rect.at[cur_aname] = _at.fval;
elif cur_dtype == AnnotationLib.AnnoList.TYPE_STRING:
rect.at[cur_aname] = _at.strval;
else:
assert(False);
anno.rects.append(rect);
annotations.append(anno);
return annotations;
def add_rectangles(H, orig_image, confidences, boxes, depths, locations, corners, use_stitching=False, rnn_len=1, min_conf=0.1, show_removed=True, tau=0.25,
color_removed=(0, 0, 255), color_acc=(0, 0, 255)):
image = np.copy(orig_image[0])
num_cells = H["grid_height"] * H["grid_width"]
boxes_r = np.reshape(boxes, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
4))
confidences_r = np.reshape(confidences, (-1,
H["grid_height"],
H["grid_width"],
rnn_len,
H['num_classes']))
depths_r = np.reshape(depths, (-1,
H['grid_height'],
H['grid_width'],
rnn_len,
1))
locations_r = np.reshape(locations, (-1,
H['grid_height'],
H['grid_width'],
rnn_len,
3))
corners_r = np.reshape(corners, (-1, 3, 8))
dimensions_yaw = [get_dimensions(corners_r[index]) for index in range(corners_r.shape[0])]
dimensions_yaw = np.reshape(dimensions_yaw, (-1,
H['grid_height'],
H['grid_width'],
rnn_len,
4))
cell_pix_size = H['region_size']
all_rects = [[[] for _ in range(H["grid_width"])] for _ in range(H["grid_height"])]
for n in range(rnn_len):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
abs_cx = int(bbox[0]) + cell_pix_size/2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size/2 + cell_pix_size * y
w = bbox[2]
h = bbox[3]
depth = depths_r[0, y, x, n, 0]
location = locations_r[0, y, x, n, :]
dims_alpha = dimensions_yaw[0, y, x, n, :]
conf = np.max(confidences_r[0, y, x, n, 1:])
all_rects[y][x].append(Rect(abs_cx,abs_cy,w,h,conf,depth,location[0],location[1],location[2],dims_alpha[0],dims_alpha[1],dims_alpha[2],dims_alpha[3]))
all_rects_r = [r for row in all_rects for cell in row for r in cell]
if use_stitching:
from utils.stitch_wrapper import stitch_rects
acc_rects = stitch_rects(all_rects, tau)
else:
acc_rects = all_rects_r
if not show_removed:
all_rects_r = []
pairs = [(all_rects_r, color_removed), (acc_rects, color_acc)]
im = Image.fromarray(image.astype('uint8'))
draw = ImageDraw.Draw(im)
for rect_set, color in pairs:
for rect in rect_set:
if rect.confidence > min_conf:
_draw_rect(draw, rect, color)
image = np.array(im).astype('float32')
rects = []
for rect in acc_rects:
if rect.confidence < min_conf:
continue
r = al.AnnoRect()
r.x1 = rect.cx - rect.width/2.
r.x2 = rect.cx + rect.width/2.
r.y1 = rect.cy - rect.height/2.
r.y2 = rect.cy + rect.height/2.
r.score = rect.true_confidence
r.x_3d = rect.x_3d
r.y_3d = rect.y_3d
r.z_3d = rect.z_3d
r.height_3d = rect.height_3d
r.width_3d = rect.width_3d
r.length_3d = rect.length_3d
r.alpha = rect.alpha
view_angle = np.arctan2(rect.z_3d, rect.x_3d)
r.alpha += np.pi * 0.5 - view_angle
rects.append(r)
return image, rects
def add_rectangles(H,
orig_image,
confidences,
boxes,
use_stitching=False,
rnn_len=1,
min_conf=0.1,
show_removed=True,
tau=0.25,
color_removed=(0, 0, 255),
color_acc=(0, 0, 255)):
image = np.copy(orig_image[0])
num_cells = H["grid_height"] * H["grid_width"]
boxes_r = np.reshape(boxes,
(-1, H["grid_height"], H["grid_width"], rnn_len, 4))
confidences_r = np.reshape(
confidences,
(-1, H["grid_height"], H["grid_width"], rnn_len, H['num_classes']))
cell_pix_size = H['region_size']
all_rects = [[[] for _ in range(H["grid_width"])]
for _ in range(H["grid_height"])]
for n in range(rnn_len):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
abs_cx = int(bbox[0]) + cell_pix_size / 2 + cell_pix_size * x
abs_cy = int(bbox[1]) + cell_pix_size / 2 + cell_pix_size * y
w = bbox[2]
h = bbox[3]
conf = np.max(confidences_r[0, y, x, n, 1:])
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
all_rects_r = [r for row in all_rects for cell in row for r in cell]
if use_stitching:
from stitch_wrapper import stitch_rects
acc_rects = stitch_rects(all_rects, tau)
else:
acc_rects = all_rects_r
if not show_removed:
all_rects_r = []
pairs = [(all_rects_r, color_removed), (acc_rects, color_acc)]
im = Image.fromarray(image.astype('uint8'))
draw = ImageDraw.Draw(im)
for rect_set, color in pairs:
for rect in rect_set:
if rect.confidence > min_conf:
_draw_rect(draw, rect, color)
image = np.array(im).astype('float32')
rects = []
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
rects.append(r)
return image, rects
def test(config):
""" Takes the config, run test program
"""
data_mean = load_data_mean(config["data"]["idl_mean"],
config["net"]["img_width"],
config["net"]["img_height"],
image_scaling=1.0)
num_test_images = 599
# Warning: load_idl returns an infinite generator. Calling list() before islice() will hang.
test_list = list(
itertools.islice(
load_idl(config["data"]["test_idl"], data_mean, config["net"],
False), 0, num_test_images))
img = np.copy(test_list[-1]["raw"])
# plt.imshow(img)
net = apollocaffe.ApolloNet()
net.phase = 'test'
forward(net, test_list[0], config["net"], True)
net.load("data/snapshot/reinspect_hcs_800000.h5")
annolist = al.AnnoList()
net_config = config["net"]
pix_per_w = net_config["img_width"] / net_config["grid_width"]
pix_per_h = net_config["img_height"] / net_config["grid_height"]
if config.has_key("conf_th"):
conf_th = config["conf_th"]
else:
conf_th = 0.6
mae = 0.
for i in range(num_test_images):
inputs = test_list[i]
bbox_list, conf_list = forward(net, inputs, net_config, True)
img = np.copy(inputs["raw"])
all_rects = [[[] for x in range(net_config["grid_width"])]
for y in range(net_config["grid_height"])]
for n in range(len(bbox_list)):
for k in range(net_config["grid_height"] *
net_config["grid_width"]):
y = int(k / net_config["grid_width"])
x = int(k % net_config["grid_width"])
bbox = bbox_list[n][k]
conf = conf_list[n][k, 1].flatten()[0]
# notice the output rect [cx, cy, w, h]
# cx means center x-cord
abs_cx = pix_per_w / 2 + pix_per_w * x + int(bbox[0, 0, 0])
abs_cy = pix_per_h / 2 + pix_per_h * y + int(bbox[1, 0, 0])
w = bbox[2, 0, 0]
h = bbox[3, 0, 0]
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
acc_rects = stitch_rects(all_rects)
display = True
if display:
for rect in acc_rects:
if rect.true_confidence < conf_th:
continue
cv2.rectangle(img, (rect.cx - int(rect.width / 2),
rect.cy - int(rect.height / 2)),
(rect.cx + int(rect.width / 2),
rect.cy + int(rect.height / 2)), (255, 0, 0), 2)
# cv2.circle(img,
# (rect.cx, rect.cy),
# ((rect.width + rect.height)/4),
# (255,0,0),
# 2)
img_name = './data/tmp/%05d.jpg' % i
plt.imsave(img_name, img)
plt.figure(figsize=(15, 10))
plt.imshow(img)
anno = al.Annotation()
anno.imageName = inputs["imname"]
# count
number = 0
for rect in acc_rects:
r = al.AnnoRect()
r.x1 = rect.cx - rect.width / 2.
r.x2 = rect.cx + rect.width / 2.
r.y1 = rect.cy - rect.height / 2.
r.y2 = rect.cy + rect.height / 2.
r.score = rect.true_confidence
anno.rects.append(r)
if r.score > conf_th:
number += 1
annolist.append(anno)
mae += abs(number - len(inputs["rects"]))
print anno.imageName, number, len(
inputs["rects"]), abs(number - len(inputs["rects"]))
print mae / num_test_images
def add_rectangles(H,
orig_image,
confidences,
boxes,
use_stitching=False,
rnn_len=1,
min_conf=0.1,
show_removed=True,
tau=0.25,
show_suppressed=True):
image = np.copy(orig_image[0])
num_cells = H["grid_height"] * H["grid_width"]
boxes_r = np.reshape(boxes,
(-1, H["grid_height"], H["grid_width"], rnn_len, 4))
confidences_r = np.reshape(
confidences,
(-1, H["grid_height"], H["grid_width"], rnn_len, H['num_classes']))
cell_pix_size = H['region_size']
# all_rects is an "array" of lists (grid_height, grid_width, ?) that builds up all of the bounding boxes
# found in each cell. Ultimately the 3rd dimension will have length num_boxes_in_cell
all_rects = [[[] for _ in range(H["grid_width"])]
for _ in range(H["grid_height"])]
for n in range(rnn_len):
for y in range(H["grid_height"]):
for x in range(H["grid_width"]):
bbox = boxes_r[0, y, x, n, :]
# These next couple lines appear to convert from cell-based coordinates to absolute image coordinates
# i.e. the origin corner of the bounding box is defined relative to a cell, not the origin of the image
abs_cx = int(bbox[0]) + old_div(cell_pix_size,
2) + cell_pix_size * x
abs_cy = int(bbox[1]) + old_div(cell_pix_size,
2) + cell_pix_size * y
# However, width and height of bounding box are still in absolute original pixels
w = bbox[2]
h = bbox[3]
# Appear to be taking the confidence of every class but the first (assuming they add to 1...),
# Or maybe this is designed only for binary classification now
conf = np.max(confidences_r[0, y, x, n, 1:])
all_rects[y][x].append(Rect(abs_cx, abs_cy, w, h, conf))
all_rects_r = [r for row in all_rects for cell in row for r in cell]
# Stitching looks a lot like a hacky way to deal with what are essentially bad predictions
if use_stitching:
from stitch_wrapper import stitch_rects
acc_rects = stitch_rects(all_rects, tau)
else:
acc_rects = all_rects_r
# Pairs is a list of tuples: ([list of rect bounding boxes in openCV format], RGB_tuple)
if show_suppressed:
# Red if it's an originally predicted box
pairs = [(all_rects_r, (255, 0, 0))]
else:
pairs = []
# Green if it's a stitched box
pairs.append((acc_rects, (0, 255, 0)))
for rect_set, color in pairs:
# The important part here is that acc_rects is drawn AFTER all_rects... so green boxes should appear over red ones
for rect in rect_set:
if rect.confidence > min_conf:
# min_conf default is 0.1...
# So it appears that low-confidence rects that were later stitched are drawn
cv2.rectangle(image, (rect.cx - int(old_div(rect.width, 2)),
rect.cy - int(old_div(rect.height, 2))),
(rect.cx + int(old_div(rect.width, 2)),
rect.cy + int(old_div(rect.height, 2))), color,
1)
cv2.putText(
image,
str(len([rect for rect in acc_rects if rect.confidence > min_conf])),
(50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
rects = []
for rect in acc_rects:
if rect.confidence > min_conf:
r = al.AnnoRect()
r.x1 = rect.cx - old_div(rect.width, 2.)
r.x2 = rect.cx + old_div(rect.width, 2.)
r.y1 = rect.cy - old_div(rect.height, 2.)
r.y2 = rect.cy + old_div(rect.height, 2.)
r.score = rect.confidence
rects.append(r)
return image, rects
def read_kitti_anno(label_file, detect_truck):
""" Reads a kitti annotation file.
Args:
label_file: Path to file
Returns:
Lists of rectangels: Cars and don't care area.
"""
labels = [line.rstrip().split(' ') for line in open(label_file)]
rect_list = []
for label in labels:
if not (label[0] == 'Car' or label[0] == 'Pedestrian' or
label[0] == 'Truck' or label[0] == 'DontCare'):
continue
notruck = not detect_truck
if notruck and label[0] == 'Truck':
continue
class_id = -100
if label[0] == 'DontCare':
class_id = -1
if label[0] == 'Car':
class_id = 1
if label[0] == 'Pedestrian':
class_id = 2
#if label[0] == 'Cyclist':
#class_id = 3
print("***123456***");
print(label[0]);
print(class_id);
print("***123456***");
object_rect = AnnoLib.AnnoRect(
x1=float(label[4]), y1=float(label[5]),
x2=float(label[6]), y2=float(label[7]))
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
rect_list.append(object_rect)
'''w=float(label[6])-float(label[4])
h=float(label[7])-float(label[5])
if class_id == 2:
for x_scale_factor in ([-0.25,0,0.25]):
#print("**********")
#print(x_scale_factor)
x_offset=w*x_scale_factor
x_1=float(label[4])+x_offset
x_1=max(0,x_1)
x_2=float(label[6])+x_offset
x_2=min(x_2,1280)
for y_scale_factor in ([-0.25,0,0.25]):
print("*********")
print("({},{})".format(x_scale_factor,y_scale_factor))
y_offset=h*y_scale_factor
y_1=float(label[5])+y_offset
y_1=max(0,y_1)
y_2=float(label[7])+y_offset
y_2=min(y_2,1280)
object_rect_aug=AnnoLib.AnnoRect(x1=x_1,x2=x_2,y1=y_1,y2=y_2)
assert object_rect.x1 < object_rect.x2
assert object_rect.y1 < object_rect.y2
object_rect.classID = class_id
rect_list.append(object_rect)'''
return rect_list
