def draw_3d_predictions(filtered_gt_objs, p_matrix, predictions_to_show,
prediction_objs, prediction_class, final_boxes,
pred_3d_axes, draw_score, draw_iou, gt_classes,
draw_orientations_on_pred):
# Draw filtered ground truth boxes
gt_boxes = []
for obj in filtered_gt_objs:
# Draw 3D boxes
vis_utils.draw_box_3d(pred_3d_axes,
obj,
p_matrix,
show_orientation=draw_orientations_on_pred,
color_table=['r', 'y', 'r', 'w'],
line_width=2,
double_line=False)
if draw_iou:
gt_box_2d = [obj.x1, obj.y1, obj.x2, obj.y2]
gt_boxes.append(gt_box_2d)
if gt_boxes:
# the two_2 eval function expects np.array
gt_boxes = np.asarray(gt_boxes)
for pred_idx in range(predictions_to_show):
pred_obj = prediction_objs[pred_idx]
pred_class_idx = prediction_class[pred_idx]
rgb_box_2d = final_boxes[pred_idx]
box_x1 = rgb_box_2d[0]
box_y1 = rgb_box_2d[1]
# Draw 3D boxes
box_cls = gt_classes[int(pred_class_idx)]
vis_utils.draw_box_3d(pred_3d_axes,
pred_obj,
p_matrix,
show_orientation=draw_orientations_on_pred,
color_table=['#00FF00', 'y', 'r', 'w'],
line_width=2,
double_line=False,
box_color=BOX_COLOUR_SCHEME[box_cls])
if draw_score or draw_iou:
box_x2 = rgb_box_2d[2]
box_y2 = rgb_box_2d[3]
pred_box_2d = [box_x1, box_y1, box_x2, box_y2]
info_text_x = (box_x1 + box_x2) / 2
info_text_y = box_y1
draw_prediction_info(pred_3d_axes, info_text_x, info_text_y,
pred_obj, pred_class_idx, pred_box_2d,
gt_boxes, draw_score, draw_iou, gt_classes)
def draw_gt(gt_objects, prop_2d_axes, prop_3d_axes, p_matrix):
# Draw filtered ground truth boxes
for obj in gt_objects:
# Draw 2D boxes
vis_utils.draw_box_2d(prop_2d_axes, obj, test_mode=True, color_tm='r')
# Draw 3D boxes
vis_utils.draw_box_3d(prop_3d_axes, obj, p_matrix,
show_orientation=False,
color_table=['r', 'y', 'r', 'w'],
line_width=2,
double_line=False)
def draw_proposals(filtered_gt_objs, p_matrix, num_of_proposals, proposal_objs,
proposal_boxes, prop_2d_axes, prop_3d_axes,
draw_orientations_on_prop):
# Draw filtered ground truth boxes
for obj in filtered_gt_objs:
# Draw 2D boxes
vis_utils.draw_box_2d(prop_2d_axes,
obj,
test_mode=True,
color_tm='r',
linewidth=linewidth)
# Draw 3D boxes
vis_utils.draw_box_3d(prop_3d_axes,
obj,
p_matrix,
show_orientation=draw_orientations_on_prop,
color_table=['r', 'y', 'r', 'w'],
line_width=line_width,
double_line=False)
# Overlay proposal boxes on images
for anchor_idx in range(num_of_proposals):
obj_label = proposal_objs[anchor_idx]
# Draw 2D boxes (can't use obj_label since 2D corners are not
# filled in)
rgb_box_2d = proposal_boxes[anchor_idx]
box_x1 = rgb_box_2d[0]
box_y1 = rgb_box_2d[1]
box_w = rgb_box_2d[2] - box_x1
box_h = rgb_box_2d[3] - box_y1
rect = patches.Rectangle((box_x1, box_y1),
box_w,
box_h,
linewidth=line_width,
edgecolor='cornflowerblue',
facecolor='none')
prop_2d_axes.add_patch(rect)
# Draw 3D boxes
vis_utils.draw_box_3d(prop_3d_axes,
obj_label,
p_matrix,
show_orientation=draw_orientations_on_prop,
color_table=['cornflowerblue', 'y', 'r', 'w'],
line_width=line_width,
double_line=False)
def draw_boxes(objects, calib, plot_axes):
all_corners = []
for obj in objects:
if hasattr(obj, 'type_label'):
obj.obj_type = obj.type_label
else:
obj.obj_type = obj.type
if not hasattr(obj, 'truncation'):
obj.truncation = 0
if not hasattr(obj, 'occlusion'):
obj.occlusion = 0
if not hasattr(obj, 'score'):
obj.score = 1
if obj.obj_type not in type_whitelist:
continue
vis_utils.draw_box_3d(plot_axes, obj, calib.P,
show_orientation=False,
color_table=['r', 'y', 'r', 'w'],
line_width=2,
double_line=False)
box3d_pts_2d, corners = utils.compute_box_3d(obj, calib.P)
if box3d_pts_2d is None:
continue
all_corners.append(corners)
# draw text info
x1 = np.amin(box3d_pts_2d, axis=0)[0]
y1 = np.amin(box3d_pts_2d, axis=0)[1]
x2 = np.amax(box3d_pts_2d, axis=0)[0]
y2 = np.amax(box3d_pts_2d, axis=0)[1]
text_x = (x1 + x2) / 2
text_y = y1
text = "{}\n{:.2f}".format(obj.obj_type, obj.score)
plot_axes.text(text_x, text_y - 4,
text,
verticalalignment='bottom',
horizontalalignment='center',
color=BOX_COLOUR_SCHEME[obj.obj_type],
fontsize=10,
fontweight='bold',
path_effects=[
patheffects.withStroke(linewidth=2,
foreground='black')])
return all_corners
def main():
# Start of the Kitti demo code
print('=== Python Kitti Wrapper Demo ===')
# Setting Paths
data_set = 'training'
cam = 2
root_dir = '/notebooks/DATA/Kitti/object/' #os.path.expanduser('~') + '/Kitti/object/'
image_dir = os.path.join(root_dir, data_set) + '/image_' + str(cam)
label_dir = os.path.join(root_dir, data_set) + '/label_' + str(cam)
calib_dir = os.path.join(root_dir, data_set) + '/calib'
img_idx = int(random.random() * 100)
print('img_idx', img_idx)
# Run Visualization Function
f, ax1, ax2 = vis_utils.visualization(image_dir, img_idx)
# Run the main loop to run throughout the images
frame_calibration_info = calib_utils.read_calibration(calib_dir, img_idx)
p = frame_calibration_info.p2
# Load labels
objects = obj_utils.read_labels(label_dir, img_idx)
# For all annotated objects
for obj in objects:
# Draw 2D and 3D boxes
vis_utils.draw_box_2d(ax1, obj)
vis_utils.draw_box_3d(ax2, obj, p)
# Render results
plt.draw()
plt.show()
def draw_boxes(prediction, sample, plot_axes):
all_corners = []
for pred in prediction:
box = np.array(pred[0:7])
cls_idx = int(pred[8])
obj = box_3d_encoder.box_3d_to_object_label(box, obj_type=type_whitelist[cls_idx])
obj.score = pred[7]
vis_utils.draw_box_3d(plot_axes, obj, sample[constants.KEY_STEREO_CALIB_P2],
show_orientation=False,
color_table=['r', 'y', 'r', 'w'],
line_width=2,
double_line=False)
corners = compute_box_3d(obj)
all_corners.append(corners)
# draw text info
projected = calib_utils.project_to_image(corners.T, sample[constants.KEY_STEREO_CALIB_P2])
x1 = np.amin(projected[0])
y1 = np.amin(projected[1])
x2 = np.amax(projected[0])
y2 = np.amax(projected[1])
text_x = (x1 + x2) / 2
text_y = y1
text = "{}\n{:.2f}".format(obj.type, obj.score)
plot_axes.text(text_x, text_y - 4,
text,
verticalalignment='bottom',
horizontalalignment='center',
color=BOX_COLOUR_SCHEME[obj.type],
fontsize=10,
fontweight='bold',
path_effects=[
patheffects.withStroke(linewidth=2,
foreground='black')])
return all_corners
def main():
"""
Visualization of 3D grid anchor generation, showing 2D projections
in BEV and image space, and a 3D display of the anchors
"""
dataset_config = DatasetBuilder.copy_config(DatasetBuilder.KITTI_TRAIN)
dataset_config.num_clusters[0] = 1
dataset = DatasetBuilder.build_kitti_dataset(dataset_config)
label_cluster_utils = LabelClusterUtils(dataset)
clusters, _ = label_cluster_utils.get_clusters()
# Options
img_idx = 1
# fake_clusters = np.array([[5, 4, 3], [6, 5, 4]])
# fake_clusters = np.array([[3, 3, 3], [4, 4, 4]])
fake_clusters = np.array([[4, 2, 3]])
fake_anchor_stride = [5.0, 5.0]
ground_plane = [0, -1, 0, 1.72]
anchor_3d_generator = grid_anchor_3d_generator.GridAnchor3dGenerator()
area_extents = np.array([[-40, 40], [-5, 5], [0, 70]])
# Generate anchors for cars only
start_time = time.time()
anchor_boxes_3d = anchor_3d_generator.generate(
area_3d=dataset.kitti_utils.area_extents,
anchor_3d_sizes=fake_clusters,
anchor_stride=fake_anchor_stride,
ground_plane=ground_plane)
all_anchors = box_3d_encoder.box_3d_to_anchor(anchor_boxes_3d)
end_time = time.time()
print("Anchors generated in {} s".format(end_time - start_time))
# Project into bev
bev_boxes, bev_normalized_boxes = \
anchor_projector.project_to_bev(all_anchors, area_extents[[0, 2]])
bev_fig, (bev_axes, bev_normalized_axes) = \
plt.subplots(1, 2, figsize=(16, 7))
bev_axes.set_xlim(0, 80)
bev_axes.set_ylim(70, 0)
bev_normalized_axes.set_xlim(0, 1.0)
bev_normalized_axes.set_ylim(1, 0.0)
plt.show(block=False)
for box in bev_boxes:
box_w = box[2] - box[0]
box_h = box[3] - box[1]
rect = patches.Rectangle((box[0], box[1]),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
bev_axes.add_patch(rect)
for normalized_box in bev_normalized_boxes:
box_w = normalized_box[2] - normalized_box[0]
box_h = normalized_box[3] - normalized_box[1]
rect = patches.Rectangle((normalized_box[0], normalized_box[1]),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
bev_normalized_axes.add_patch(rect)
rgb_fig, rgb_2d_axes, rgb_3d_axes = \
vis_utils.visualization(dataset.rgb_image_dir, img_idx)
plt.show(block=False)
image_path = dataset.get_rgb_image_path(dataset.sample_names[img_idx])
image_shape = np.array(Image.open(image_path)).shape
stereo_calib_p2 = calib_utils.read_calibration(dataset.calib_dir,
img_idx).p2
start_time = time.time()
rgb_boxes, rgb_normalized_boxes = \
anchor_projector.project_to_image_space(all_anchors,
stereo_calib_p2,
image_shape)
end_time = time.time()
print("Anchors projected in {} s".format(end_time - start_time))
# Read the stereo calibration matrix for visualization
stereo_calib = calib_utils.read_calibration(dataset.calib_dir, 0)
p = stereo_calib.p2
# Overlay boxes on images
for anchor_idx in range(len(anchor_boxes_3d)):
anchor_box_3d = anchor_boxes_3d[anchor_idx]
obj_label = box_3d_encoder.box_3d_to_object_label(anchor_box_3d)
# Draw 3D boxes
vis_utils.draw_box_3d(rgb_3d_axes, obj_label, p)
# Draw 2D boxes
rgb_box_2d = rgb_boxes[anchor_idx]
box_x1 = rgb_box_2d[0]
box_y1 = rgb_box_2d[1]
box_w = rgb_box_2d[2] - box_x1
box_h = rgb_box_2d[3] - box_y1
rect = patches.Rectangle((box_x1, box_y1),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
rgb_2d_axes.add_patch(rect)
if anchor_idx % 32 == 0:
rgb_fig.canvas.draw()
plt.show(block=True)
def draw_predictions(filtered_gt_objs,
p_matrix,
predictions_to_show,
prediction_objs,
prediction_class,
final_boxes,
pred_2d_axes,
pred_3d_axes,
draw_score,
draw_iou,
gt_classes,
draw_orientations_on_pred,
iou_3d):
# Draw filtered ground truth boxes
gt_boxes = []
gt_boxes_3d = []
for obj in filtered_gt_objs:
# Draw 2D boxes
vis_utils.draw_box_2d(
pred_2d_axes, obj, test_mode=True, color_tm='r')
# Draw 3D boxes
vis_utils.draw_box_3d(pred_3d_axes, obj, p_matrix,
show_orientation=draw_orientations_on_pred,
color_table=['r', 'y', 'r', 'w'],
line_width=2,
double_line=False)
if draw_iou:
gt_box_2d = [obj.x1, obj.y1, obj.x2, obj.y2]
gt_boxes.append(gt_box_2d)
if iou_3d:
gt_box_3d = [obj.ry, obj.l, obj.h, obj.w, obj.t[0], obj.t[1], obj.t[2]]
gt_boxes_3d.append(gt_box_3d)
if gt_boxes:
# the two_2 eval function expects np.array
gt_boxes = np.asarray(gt_boxes)
if iou_3d:
gt_boxes_3d = np.asarray(gt_boxes_3d)
for pred_idx in range(predictions_to_show):
pred_obj = prediction_objs[pred_idx]
pred_class_idx = prediction_class[pred_idx]
rgb_box_2d = final_boxes[pred_idx]
box_x1 = rgb_box_2d[0]
box_y1 = rgb_box_2d[1]
box_w = rgb_box_2d[2] - box_x1
box_h = rgb_box_2d[3] - box_y1
box_cls = gt_classes[int(pred_class_idx)]
rect = patches.Rectangle((box_x1, box_y1),
box_w, box_h,
linewidth=2,
edgecolor=BOX_COLOUR_SCHEME[box_cls],
facecolor='none')
pred_2d_axes.add_patch(rect)
# Draw 3D boxes
vis_utils.draw_box_3d(pred_3d_axes, pred_obj, p_matrix,
show_orientation=draw_orientations_on_pred,
color_table=['#00FF00', 'y', 'r', 'w'],
line_width=2,
double_line=False,
box_color=BOX_COLOUR_SCHEME[box_cls])
if draw_score or draw_iou:
box_x2 = rgb_box_2d[2]
box_y2 = rgb_box_2d[3]
pred_box_2d = [box_x1,
box_y1,
box_x2,
box_y2]
info_text_x = (box_x1 + box_x2) / 2
info_text_y = box_y1
if iou_3d:
pred_box_3d = np.asarray([pred_obj.ry, pred_obj.l, pred_obj.h, pred_obj.w, pred_obj.t[0], pred_obj.t[1], pred_obj.t[2]])
draw_prediction_info(pred_2d_axes,
info_text_x,
info_text_y,
pred_obj,
pred_class_idx,
pred_box_3d,
gt_boxes_3d,
draw_score,
draw_iou,
gt_classes,
iou_3d)
else:
draw_prediction_info(pred_2d_axes,
info_text_x,
info_text_y,
pred_obj,
pred_class_idx,
pred_box_2d,
gt_boxes,
draw_score,
draw_iou,
gt_classes,
iou_3d)
def main():
"""
Visualization of 3D grid anchor generation, showing 2D projections
in BEV and image space, and a 3D display of the anchors
"""
dataset_config = DatasetBuilder.copy_config(DatasetBuilder.KITTI_TRAIN)
dataset_config.num_clusters[0] = 1
dataset = DatasetBuilder.build_kitti_dataset(dataset_config)
label_cluster_utils = LabelClusterUtils(dataset)
clusters, _ = label_cluster_utils.get_clusters()
# Options
img_idx = 1
# fake_clusters = np.array([[5, 4, 3], [6, 5, 4]])
# fake_clusters = np.array([[3, 3, 3], [4, 4, 4]])
fake_clusters = np.array([[4, 2, 3]])
fake_anchor_stride = [5.0, 5.0]
ground_plane = [0, -1, 0, 1.72]
anchor_3d_generator = grid_anchor_3d_generator.GridAnchor3dGenerator()
area_extents = np.array([[-40, 40], [-5, 5], [0, 70]])
# Generate anchors for cars only
start_time = time.time()
anchor_boxes_3d = anchor_3d_generator.generate(
area_3d=dataset.kitti_utils.area_extents,
anchor_3d_sizes=fake_clusters,
anchor_stride=fake_anchor_stride,
ground_plane=ground_plane)
all_anchors = box_3d_encoder.box_3d_to_anchor(anchor_boxes_3d)
end_time = time.time()
print("Anchors generated in {} s".format(end_time - start_time))
# Project into bev
bev_boxes, bev_normalized_boxes = \
anchor_projector.project_to_bev(all_anchors, area_extents[[0, 2]])
bev_fig, (bev_axes, bev_normalized_axes) = \
plt.subplots(1, 2, figsize=(16, 7))
bev_axes.set_xlim(0, 80)
bev_axes.set_ylim(70, 0)
bev_normalized_axes.set_xlim(0, 1.0)
bev_normalized_axes.set_ylim(1, 0.0)
plt.show(block=False)
for box in bev_boxes:
box_w = box[2] - box[0]
box_h = box[3] - box[1]
rect = patches.Rectangle((box[0], box[1]),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
bev_axes.add_patch(rect)
for normalized_box in bev_normalized_boxes:
box_w = normalized_box[2] - normalized_box[0]
box_h = normalized_box[3] - normalized_box[1]
rect = patches.Rectangle((normalized_box[0], normalized_box[1]),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
bev_normalized_axes.add_patch(rect)
rgb_fig, rgb_2d_axes, rgb_3d_axes = \
vis_utils.visualization(dataset.rgb_image_dir, img_idx)
plt.show(block=False)
image_path = dataset.get_rgb_image_path(dataset.sample_names[img_idx])
image_shape = np.array(Image.open(image_path)).shape
stereo_calib_p2 = calib_utils.read_calibration(dataset.calib_dir,
img_idx).p2
start_time = time.time()
rgb_boxes, rgb_normalized_boxes = \
anchor_projector.project_to_image_space(all_anchors,
stereo_calib_p2,
image_shape)
end_time = time.time()
print("Anchors projected in {} s".format(end_time - start_time))
# Read the stereo calibration matrix for visualization
stereo_calib = calib_utils.read_calibration(dataset.calib_dir, 0)
p = stereo_calib.p2
# Overlay boxes on images
anchor_objects = []
for anchor_idx in range(len(anchor_boxes_3d)):
anchor_box_3d = anchor_boxes_3d[anchor_idx]
obj_label = box_3d_encoder.box_3d_to_object_label(anchor_box_3d)
# Append to a list for visualization in VTK later
anchor_objects.append(obj_label)
# Draw 3D boxes
vis_utils.draw_box_3d(rgb_3d_axes, obj_label, p)
# Draw 2D boxes
rgb_box_2d = rgb_boxes[anchor_idx]
box_x1 = rgb_box_2d[0]
box_y1 = rgb_box_2d[1]
box_w = rgb_box_2d[2] - box_x1
box_h = rgb_box_2d[3] - box_y1
rect = patches.Rectangle((box_x1, box_y1),
box_w,
box_h,
linewidth=2,
edgecolor='b',
facecolor='none')
rgb_2d_axes.add_patch(rect)
if anchor_idx % 32 == 0:
rgb_fig.canvas.draw()
plt.show(block=False)
# Create VtkGroundPlane for ground plane visualization
vtk_ground_plane = VtkGroundPlane()
vtk_ground_plane.set_plane(ground_plane, area_extents[[0, 2]])
# Create VtkAxes
axes = vtk.vtkAxesActor()
axes.SetTotalLength(5, 5, 5)
# Create VtkBoxes for boxes
vtk_boxes = VtkBoxes()
vtk_boxes.set_objects(anchor_objects, vtk_boxes.COLOUR_SCHEME_KITTI)
# Create Voxel Grid Renderer in bottom half
vtk_renderer = vtk.vtkRenderer()
vtk_renderer.AddActor(vtk_boxes.vtk_actor)
vtk_renderer.AddActor(vtk_ground_plane.vtk_actor)
vtk_renderer.AddActor(axes)
vtk_renderer.SetBackground(0.2, 0.3, 0.4)
# Setup Camera
current_cam = vtk_renderer.GetActiveCamera()
current_cam.Pitch(170.0)
current_cam.Roll(180.0)
# Zooms out to fit all points on screen
vtk_renderer.ResetCamera()
# Zoom in slightly
current_cam.Zoom(2.5)
# Reset the clipping range to show all points
vtk_renderer.ResetCameraClippingRange()
# Setup Render Window
vtk_render_window = vtk.vtkRenderWindow()
vtk_render_window.SetWindowName("Anchors")
vtk_render_window.SetSize(900, 500)
vtk_render_window.AddRenderer(vtk_renderer)
# Setup custom interactor style, which handles mouse and key events
vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()
vtk_render_window_interactor.SetRenderWindow(vtk_render_window)
vtk_render_window_interactor.SetInteractorStyle(
vtk.vtkInteractorStyleTrackballCamera())
# Render in VTK
vtk_render_window.Render()
vtk_render_window_interactor.Start() # Blocking