def evaluate(model, config, data, execinfo, metrics, metrics_CV2, results,
results_CV2, recompute):
"""Wave evaluation"""
predict(model, config, data, execinfo, results, results_CV2, recompute)
# IF IT'S NOT THE OVERALL EVALUATION
leads = np.concatenate((pandas.Index(execinfo.test) + '_0',
pandas.Index(execinfo.test) + '_1'))
retrieve_fiducials(results, leads, recompute)
retrieve_fiducials(results_CV2, leads, recompute)
### COMPUTE METRICS ###
metric_computation(config, data, metrics, results, execinfo.test,
recompute)
metric_computation(config, data, metrics_CV2, results_CV2, execinfo.test,
recompute)
### SAVE RESULTS ###
path_CV2 = os.path.splitext(
execinfo.results)[0] + '_CV2' + os.path.splitext(execinfo.results)[1]
save_results(metrics, config, execinfo.test, execinfo.results)
save_results(metrics_CV2, config, execinfo.test, path_CV2)
def start_video(self, model):
camera = cv2.VideoCapture(0)
while True:
frame = camera.read()[1]
if frame is None:
continue
image_array = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
selected_boxes = predict(model, image_array, prior_boxes,
frame.shape[0:2], self.num_classes,
self.lower_probability_threshold,
self.iou_threshold, self.background_index,
self.box_scale_factors)
if selected_boxes is None:
continue
draw_video_boxes(selected_boxes, frame, self.arg_to_class,
self.colors, self.font)
cv2.imshow('webcam', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
camera.release()
cv2.destroyAllWindows()
num_classes = len(class_names)
data_manager = DataManager(dataset_name, selected_classes, data_prefix,
image_prefix)
ground_truth_data = data_manager.load_data()
difficult_data_flags = data_manager.parser.difficult_objects
image_names = sorted(list(ground_truth_data.keys()))
# print('Number of images found:', len(image_names))
for image_name in image_names:
ground_truth_sample = ground_truth_data[image_name]
image_prefix = data_manager.image_prefix
image_path = image_prefix + image_name
image_array, original_image_size = load_image(image_path, input_shape)
image_array = preprocess_images(image_array)
predicted_data = predict(model, image_array, prior_boxes,
original_image_size, 21, class_threshold,
iou_threshold)
ground_truth_sample = denormalize_box(ground_truth_sample,
original_image_size)
ground_truth_boxes_in_image = len(ground_truth_sample)
difficult_objects = difficult_data_flags[image_name]
difficult_objects = np.asarray(difficult_objects, dtype=bool)
num_ground_truth_boxes += np.sum(np.logical_not(difficult_objects))
if predicted_data is None:
# print('Zero predictions given for image:', image_name)
continue
#plt.imshow(original_image_array.astype('uint8'))
#plt.show()
#draw_image_boxes(predicted_data, original_image_array, class_decoder, normalized=False)
#print(predicted_data.shape)
num_predictions = len(predicted_data)
def _main(args):
start_time = timer()
input_path = os.path.expanduser(args.input_path)
output_path = os.path.expanduser(args.output_path)
if not os.path.exists(output_path):
print('Creating output path {}'.format(output_path))
os.mkdir(output_path)
logging.basicConfig(filename=output_path + "/tracking.log", level=logging.DEBUG)
#parse car positions and angles
print("Parsing timestamps and oxts files...")
if args.oxts.startswith('..'):
parse_oxts(input_path + "/" + args.oxts, input_path + "/" + args.time_stamps)
else:
parse_oxts(args.oxts, args.time_stamps)
print("Done. Data acquired.")
dataset_name = 'VOC2007'
NUM_CLASSES = 21
weights_filename = args.model_path
model = SSD300(num_classes=NUM_CLASSES)
prior_boxes = create_prior_boxes(model)
model.load_weights(weights_filename)
# drawing stuff
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / NUM_CLASSES, 1., 1.)
for x in range(NUM_CLASSES)]
colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
colors))
random.seed(10101) # Fixed seed for consistent colors across runs.
random.shuffle(colors) # Shuffle colors to decorrelate adjacent classes.
random.seed(None) # Reset seed to default.
class_names = get_class_names(dataset_name)
box_scale_factors=[.1, .1, .2, .2] # maybe adjust to our image size
background_index=0
lower_probability_threshold=.1
iou_threshold=.2
num_classes = len(class_names) # sould be equal to NUM_CLASSES
arg_to_class = dict(zip(list(range(num_classes)), class_names))
frame_idx = 0
for image_file in os.listdir(input_path):
try:
image_type = imghdr.what(os.path.join(input_path, image_file))
if not image_type:
print("frame dropped")
continue
except IsADirectoryError:
print("frame dropped")
continue
image = Image.open(os.path.join(input_path, image_file))
image_data = np.array(image)
selected_boxes = predict(model, image_data, prior_boxes,
image_data.shape[0:2], num_classes,
lower_probability_threshold,
iou_threshold,
background_index,
box_scale_factors)
if selected_boxes is not None:
x_mins = selected_boxes[:, 0]
y_mins = selected_boxes[:, 1]
x_maxs = selected_boxes[:, 2]
y_maxs = selected_boxes[:, 3]
classes = selected_boxes[:, 4:]
num_boxes = len(selected_boxes)
else:
num_boxes = 0
print("frame dropped, no boxes")
print('Found {} boxes for {}'.format(num_boxes, image_file))
font = ImageFont.truetype(
font='font/FiraMono-Medium.otf',
size=11) # np.floor(3e-2 * image.size[1] + 0.5).astype('int32')
thickness = (image_data.shape[0] + image_data.shape[1]) // 300
logging.info("Img: " + str(image_file))
boxes_data = []
for i in range(num_boxes):
xmin = int(x_mins[i])
ymin = int(y_mins[i])
xmax = int(x_maxs[i])
ymax = int(y_maxs[i])
box_class_scores = classes[i]
label_class = np.argmax(box_class_scores)
score = box_class_scores[label_class]
predicted_class = arg_to_class[label_class]
box = [ymin, xmin, ymax, xmax]
box = [max(0,v) for v in box] # sometimes it's negative.
# log positions
obj_coord = np.array([])
if predicted_class in ["person", "bicycle", "car", "motorbike", "bus", "train", "truck"] and score > 0.2: #object and classes to track
if predicted_class in ["bus", "bruck"]: #vehicle
predicted_class = "car"
obj_coord = computeCoordinates(box, frame_idx)
if obj_coord is not None:
hist = histogram(image_data, box)
#create data and store it
boxes_data.append({
'predicted_class': predicted_class,
'score': float(score),
'coord': obj_coord,
'hist': hist
})
logging.info(predicted_class + " :" + str(obj_coord) + " | " + str(np.linalg.norm(obj_coord)))
# end log positions
if saveImages:
if obj_coord is not None:
label = '{} {:.2f} {} {:.2f}'.format(predicted_class, score, str(obj_coord), np.linalg.norm(obj_coord))
else:
label = '{} {:.2f}'.format(predicted_class, score)
draw = ImageDraw.Draw(image)
label_size = draw.textsize(label, font)
top, left, bottom, right = box
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
print(label, (left, top), (right, bottom))
if top - label_size[1] >= 0:
text_origin = np.array([left, top - label_size[1]])
else:
text_origin = np.array([left, top + 1])
for i in range(thickness):
draw.rectangle(
[left + i, top + i, right - i, bottom - i],
outline=colors[label_class])
draw.rectangle(
[tuple(text_origin), tuple(text_origin + label_size)],
fill=colors[label_class])
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
del draw
frame_idx += 1
global data_frames
data_frames.append(boxes_data)
if saveImages:
image.save(os.path.join(output_path, image_file), quality=80)
now = timer()
start_trj_time = timer()
print("Time elapsed CNN: " + str(now - start_time) + " seconds")
print("Calculating trajectories...")
calculate_trajectories()
now = timer()
print("Done. Time elapsed: " + str(now - start_trj_time) + " seconds\n\n")
print("Total time elapsed: " + str(now - start_time) + " seconds")
ground_truth_sample = ground_truth_data[image_name]
image_path = image_prefix + image_name
rgb_image, image_size = load_image(image_path, target_size=(300, 300))
pytorch_image = preprocess_pytorch_input(rgb_image)
pytorch_output = pytorch_ssd(pytorch_image)
p1 = pytorch_output[0].data.numpy() # bounding boxes
p2 = softmax(np.squeeze(pytorch_output[1].data.numpy())) # classes
p3 = pytorch_output[2].data.numpy() # prior boxes
# pytorch_detections = pytorch_output.data
keras_image = preprocess_images(rgb_image)
keras_image_input = np.expand_dims(keras_image, axis=0)
keras_output = model.predict(keras_image_input)
keras_detection = predict(model, keras_image, prior_boxes, image_size,
num_classes, lower_probability_threshold,
iou_threshold, background_index)
keras_output = np.squeeze(keras_output)
k1 = keras_output[:, :4]
k2 = keras_output[:, 4:]
k3 = prior_boxes
diff = np.abs(p1 - k1)
diff_mask = .0001 > diff
all_good = np.all(diff_mask)
print(all_good)
if not all_good:
print('*' * 30)
print(image_name)
print(all_good)