diff --git a/kitti_object.py b/kitti_object.py
index d444934..80d2567 100644
--- a/kitti_object.py
+++ b/kitti_object.py
@@ -1,88 +1,91 @@
-''' Helper class and functions for loading KITTI objects
+""" Helper class and functions for loading KITTI objects
 
 Author: Charles R. Qi
 Date: September 2017
-'''
+"""
 from __future__ import print_function
 
 import os
 import sys
 import numpy as np
 import cv2
+
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(BASE_DIR)
-sys.path.append(os.path.join(ROOT_DIR, 'mayavi'))
+sys.path.append(os.path.join(ROOT_DIR, "mayavi"))
 import kitti_util as utils
 import argparse
+
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
 
-cbox = np.array([[0,70.4], [-40,40], [-3,1]])
+cbox = np.array([[0, 70.4], [-40, 40], [-3, 1]])
+
 
 class kitti_object(object):
-    '''Load and parse object data into a usable format.'''
+    """Load and parse object data into a usable format."""
 
-    def __init__(self, root_dir, split='training', args=None):
-        '''root_dir contains training and testing folders'''
+    def __init__(self, root_dir, split="training", args=None):
+        """root_dir contains training and testing folders"""
         self.root_dir = root_dir
         self.split = split
         print(root_dir, split)
         self.split_dir = os.path.join(root_dir, split)
 
-        if split == 'training':
+        if split == "training":
             self.num_samples = 7481
-        elif split == 'testing':
+        elif split == "testing":
             self.num_samples = 7518
         else:
-            print('Unknown split: %s' % (split))
+            print("Unknown split: %s" % (split))
             exit(-1)
 
-        lidar_dir = 'velodyne'
-        depth_dir = 'depth'
-        pred_dir  = 'pred'
+        lidar_dir = "velodyne"
+        depth_dir = "depth"
+        pred_dir = "pred"
         if args is not None:
             lidar_dir = args.lidar
             depth_dir = args.depthdir
-            pred_dir  = args.preddir
+            pred_dir = args.preddir
 
-        self.image_dir = os.path.join(self.split_dir, 'image_2')
-        self.label_dir = os.path.join(self.split_dir, 'label_2')
-        self.calib_dir = os.path.join(self.split_dir, 'calib')
+        self.image_dir = os.path.join(self.split_dir, "image_2")
+        self.label_dir = os.path.join(self.split_dir, "label_2")
+        self.calib_dir = os.path.join(self.split_dir, "calib")
 
-        self.depthpc_dir = os.path.join(self.split_dir, 'depth_pc')
+        self.depthpc_dir = os.path.join(self.split_dir, "depth_pc")
         self.lidar_dir = os.path.join(self.split_dir, lidar_dir)
         self.depth_dir = os.path.join(self.split_dir, depth_dir)
-        self.pred_dir  = os.path.join(self.split_dir, pred_dir)
+        self.pred_dir = os.path.join(self.split_dir, pred_dir)
 
     def __len__(self):
         return self.num_samples
 
     def get_image(self, idx):
-        assert(idx<self.num_samples)
-        img_filename = os.path.join(self.image_dir, '%06d.png'%(idx))
+        assert idx < self.num_samples
+        img_filename = os.path.join(self.image_dir, "%06d.png" % (idx))
         return utils.load_image(img_filename)
 
     def get_lidar(self, idx, dtype=np.float64, n_vec=4):
-        assert(idx<self.num_samples)
-        lidar_filename = os.path.join(self.lidar_dir, '%06d.bin'%(idx))
+        assert idx < self.num_samples
+        lidar_filename = os.path.join(self.lidar_dir, "%06d.bin" % (idx))
         print(lidar_filename)
         return utils.load_velo_scan(lidar_filename, dtype, n_vec)
 
     def get_calibration(self, idx):
-        assert(idx<self.num_samples)
-        calib_filename = os.path.join(self.calib_dir, '%06d.txt'%(idx))
+        assert idx < self.num_samples
+        calib_filename = os.path.join(self.calib_dir, "%06d.txt" % (idx))
         return utils.Calibration(calib_filename)
 
     def get_label_objects(self, idx):
-        assert(idx<self.num_samples and self.split=='training')
-        label_filename = os.path.join(self.label_dir, '%06d.txt'%(idx))
+        assert idx < self.num_samples and self.split == "training"
+        label_filename = os.path.join(self.label_dir, "%06d.txt" % (idx))
         return utils.read_label(label_filename)
 
     def get_pred_objects(self, idx):
-        assert(idx<self.num_samples)
-        pred_filename = os.path.join(self.pred_dir, '%06d.txt'%(idx))
+        assert idx < self.num_samples
+        pred_filename = os.path.join(self.pred_dir, "%06d.txt" % (idx))
         is_exist = os.path.exists(pred_filename)
         if is_exist:
             return utils.read_label(pred_filename)
@@ -90,75 +93,82 @@ def get_pred_objects(self, idx):
             return None
 
     def get_depth(self, idx):
-        assert(idx<self.num_samples)
-        img_filename = os.path.join(self.depth_dir, '%06d.png'%(idx))
+        assert idx < self.num_samples
+        img_filename = os.path.join(self.depth_dir, "%06d.png" % (idx))
         return utils.load_depth(img_filename)
 
     def get_depth_image(self, idx):
-        assert(idx<self.num_samples)
-        img_filename = os.path.join(self.depth_dir, '%06d.png'%(idx))
+        assert idx < self.num_samples
+        img_filename = os.path.join(self.depth_dir, "%06d.png" % (idx))
         return utils.load_depth(img_filename)
 
     def get_depth_pc(self, idx):
-        assert(idx<self.num_samples)
-        lidar_filename = os.path.join(self.depthpc_dir, '%06d.bin'%(idx))
+        assert idx < self.num_samples
+        lidar_filename = os.path.join(self.depthpc_dir, "%06d.bin" % (idx))
         is_exist = os.path.exists(lidar_filename)
         if is_exist:
             return utils.load_velo_scan(lidar_filename), is_exist
         else:
             return None, is_exist
-        #print(lidar_filename, is_exist)
-        #return utils.load_velo_scan(lidar_filename), is_exist
+        # print(lidar_filename, is_exist)
+        # return utils.load_velo_scan(lidar_filename), is_exist
 
     def get_top_down(self, idx):
         pass
 
     def isexist_pred_objects(self, idx):
-        assert(idx<self.num_samples and self.split=='training')
-        pred_filename = os.path.join(self.pred_dir, '%06d.txt'%(idx))
+        assert idx < self.num_samples and self.split == "training"
+        pred_filename = os.path.join(self.pred_dir, "%06d.txt" % (idx))
         return os.path.exists(pred_filename)
+
     def isexist_depth(self, idx):
-        assert(idx<self.num_samples and self.split=='training')
-        depth_filename = os.path.join(self.depth_dir, '%06d.txt'%(idx))
+        assert idx < self.num_samples and self.split == "training"
+        depth_filename = os.path.join(self.depth_dir, "%06d.txt" % (idx))
         return os.path.exists(depth_filename)
 
+
 class kitti_object_video(object):
-    ''' Load data for KITTI videos '''
+    """ Load data for KITTI videos """
+
     def __init__(self, img_dir, lidar_dir, calib_dir):
         self.calib = utils.Calibration(calib_dir, from_video=True)
         self.img_dir = img_dir
         self.lidar_dir = lidar_dir
-        self.img_filenames = sorted([os.path.join(img_dir, filename) \
-            for filename in os.listdir(img_dir)])
-        self.lidar_filenames = sorted([os.path.join(lidar_dir, filename) \
-            for filename in os.listdir(lidar_dir)])
+        self.img_filenames = sorted(
+            [os.path.join(img_dir, filename) for filename in os.listdir(img_dir)]
+        )
+        self.lidar_filenames = sorted(
+            [os.path.join(lidar_dir, filename) for filename in os.listdir(lidar_dir)]
+        )
         print(len(self.img_filenames))
         print(len(self.lidar_filenames))
-        #assert(len(self.img_filenames) == len(self.lidar_filenames))
+        # assert(len(self.img_filenames) == len(self.lidar_filenames))
         self.num_samples = len(self.img_filenames)
 
     def __len__(self):
         return self.num_samples
 
     def get_image(self, idx):
-        assert(idx<self.num_samples)
+        assert idx < self.num_samples
         img_filename = self.img_filenames[idx]
         return utils.load_image(img_filename)
 
     def get_lidar(self, idx):
-        assert(idx<self.num_samples)
+        assert idx < self.num_samples
         lidar_filename = self.lidar_filenames[idx]
         return utils.load_velo_scan(lidar_filename)
 
     def get_calibration(self, unused):
         return self.calib
 
+
 def viz_kitti_video():
-    video_path = os.path.join(ROOT_DIR, 'dataset/2011_09_26/')
-    dataset = kitti_object_video(\
-        os.path.join(video_path, '2011_09_26_drive_0023_sync/image_02/data'),
-        os.path.join(video_path, '2011_09_26_drive_0023_sync/velodyne_points/data'),
-        video_path)
+    video_path = os.path.join(ROOT_DIR, "dataset/2011_09_26/")
+    dataset = kitti_object_video(
+        os.path.join(video_path, "2011_09_26_drive_0023_sync/image_02/data"),
+        os.path.join(video_path, "2011_09_26_drive_0023_sync/velodyne_points/data"),
+        video_path,
+    )
     print(len(dataset))
     for i in range(len(dataset)):
         img = dataset.get_image(0)
@@ -166,179 +176,223 @@ def viz_kitti_video():
         cv2.imshow("video", img)
         draw_lidar(pc)
         raw_input()
-        pc[:,0:3] = dataset.get_calibration().project_velo_to_rect(pc[:,0:3])
+        pc[:, 0:3] = dataset.get_calibration().project_velo_to_rect(pc[:, 0:3])
         draw_lidar(pc)
         raw_input()
     return
 
+
 def show_image_with_boxes(img, objects, calib, show3d=True, depth=None):
-    ''' Show image with 2D bounding boxes '''
-    img1 = np.copy(img) # for 2d bbox
-    img2 = np.copy(img) # for 3d bbox
-    img3 = np.copy(img) # for 3d bbox
+    """ Show image with 2D bounding boxes """
+    img1 = np.copy(img)  # for 2d bbox
+    img2 = np.copy(img)  # for 3d bbox
+    img3 = np.copy(img)  # for 3d bbox
     for obj in objects:
-        if obj.type=='DontCare': continue
-        cv2.rectangle(img1, (int(obj.xmin), int(obj.ymin)),
-            (int(obj.xmax),int(obj.ymax)), (0,255,0), 2)
+        if obj.type == "DontCare":
+            continue
+        cv2.rectangle(
+            img1,
+            (int(obj.xmin), int(obj.ymin)),
+            (int(obj.xmax), int(obj.ymax)),
+            (0, 255, 0),
+            2,
+        )
         box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
         img2 = utils.draw_projected_box3d(img2, box3d_pts_2d)
 
         # project
-        #box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
-        #box3d_pts_32d = utils.box3d_to_rgb_box00(box3d_pts_3d_velo)
-        #box3d_pts_32d = calib.project_velo_to_image(box3d_pts_3d_velo)
-        #img3 = utils.draw_projected_box3d(img3, box3d_pts_32d)
-    #print("img1:", img1.shape)
+        # box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
+        # box3d_pts_32d = utils.box3d_to_rgb_box00(box3d_pts_3d_velo)
+        # box3d_pts_32d = calib.project_velo_to_image(box3d_pts_3d_velo)
+        # img3 = utils.draw_projected_box3d(img3, box3d_pts_32d)
+    # print("img1:", img1.shape)
     cv2.imshow("2dbox", img1)
-    #print("img3:",img3.shape)
-    #Image.fromarray(img3).show()
-    show3d=True
+    # print("img3:",img3.shape)
+    # Image.fromarray(img3).show()
+    show3d = True
     if show3d:
-        #print("img2:",img2.shape)
+        # print("img2:",img2.shape)
         cv2.imshow("3dbox", img2)
     if depth is not None:
         cv2.imshow("depth", depth)
 
+
 def show_image_with_boxes_3type(img, objects, calib, objects2d, name, objects_pred):
-    ''' Show image with 2D bounding boxes '''
-    img1 = np.copy(img) # for 2d bbox
-    type_list = ['Pedestrian', 'Car', 'Cyclist']
+    """ Show image with 2D bounding boxes """
+    img1 = np.copy(img)  # for 2d bbox
+    type_list = ["Pedestrian", "Car", "Cyclist"]
     # draw Label
-    color = (0,255,0)
+    color = (0, 255, 0)
     for obj in objects:
-        if obj.type not in type_list: continue
-        cv2.rectangle(img1, (int(obj.xmin), int(obj.ymin)),
-            (int(obj.xmax),int(obj.ymax)), color, 3)
+        if obj.type not in type_list:
+            continue
+        cv2.rectangle(
+            img1,
+            (int(obj.xmin), int(obj.ymin)),
+            (int(obj.xmax), int(obj.ymax)),
+            color,
+            3,
+        )
     startx = 5
     font = cv2.FONT_HERSHEY_SIMPLEX
 
-    text_lables = [ obj.type for obj in objects if obj.type in type_list ]
-    text_lables.insert(0,"Label:")
+    text_lables = [obj.type for obj in objects if obj.type in type_list]
+    text_lables.insert(0, "Label:")
     for n in range(len(text_lables)):
-        text_pos = (startx, 25*(n+1))
+        text_pos = (startx, 25 * (n + 1))
         cv2.putText(img1, text_lables[n], text_pos, font, 0.5, color, 0, cv2.LINE_AA)
     # draw 2D Pred
-    color = (0,0,255)
+    color = (0, 0, 255)
     for obj in objects2d:
-        cv2.rectangle(img1, (int(obj.box2d[0]), int(obj.box2d[1])),
-            (int(obj.box2d[2]),int(obj.box2d[3])), color, 2)
+        cv2.rectangle(
+            img1,
+            (int(obj.box2d[0]), int(obj.box2d[1])),
+            (int(obj.box2d[2]), int(obj.box2d[3])),
+            color,
+            2,
+        )
     startx = 85
     font = cv2.FONT_HERSHEY_SIMPLEX
 
-    text_lables = [ type_list[obj.typeid-1] for obj in objects2d ]
-    text_lables.insert(0,"2D Pred:")
+    text_lables = [type_list[obj.typeid - 1] for obj in objects2d]
+    text_lables.insert(0, "2D Pred:")
     for n in range(len(text_lables)):
-        text_pos = (startx, 25*(n+1))
+        text_pos = (startx, 25 * (n + 1))
         cv2.putText(img1, text_lables[n], text_pos, font, 0.5, color, 0, cv2.LINE_AA)
     # draw 3D Pred
     if objects_pred is not None:
-        color = (255,0,0)
+        color = (255, 0, 0)
         for obj in objects_pred:
-            if obj.type not in type_list: continue
-            cv2.rectangle(img1, (int(obj.xmin), int(obj.ymin)),
-                (int(obj.xmax),int(obj.ymax)), color, 1)
+            if obj.type not in type_list:
+                continue
+            cv2.rectangle(
+                img1,
+                (int(obj.xmin), int(obj.ymin)),
+                (int(obj.xmax), int(obj.ymax)),
+                color,
+                1,
+            )
         startx = 165
         font = cv2.FONT_HERSHEY_SIMPLEX
 
-        text_lables = [ obj.type for obj in objects_pred if obj.type in type_list ]
-        text_lables.insert(0,"3D Pred:")
+        text_lables = [obj.type for obj in objects_pred if obj.type in type_list]
+        text_lables.insert(0, "3D Pred:")
         for n in range(len(text_lables)):
-            text_pos = (startx, 25*(n+1))
-            cv2.putText(img1, text_lables[n], text_pos, font, 0.5, color, 0, cv2.LINE_AA)
+            text_pos = (startx, 25 * (n + 1))
+            cv2.putText(
+                img1, text_lables[n], text_pos, font, 0.5, color, 0, cv2.LINE_AA
+            )
 
     cv2.imshow("with_bbox", img1)
-    cv2.imwrite("imgs/"+str(name)+".png", img1)
+    cv2.imwrite("imgs/" + str(name) + ".png", img1)
 
 
-def get_lidar_in_image_fov(pc_velo, calib, xmin, ymin, xmax, ymax,
-                           return_more=False, clip_distance=2.0):
-    ''' Filter lidar points, keep those in image FOV '''
+def get_lidar_in_image_fov(
+    pc_velo, calib, xmin, ymin, xmax, ymax, return_more=False, clip_distance=2.0
+):
+    """ Filter lidar points, keep those in image FOV """
     pts_2d = calib.project_velo_to_image(pc_velo)
-    fov_inds = (pts_2d[:,0]<xmax) & (pts_2d[:,0]>=xmin) & \
-        (pts_2d[:,1]<ymax) & (pts_2d[:,1]>=ymin)
-    fov_inds = fov_inds & (pc_velo[:,0]>clip_distance)
-    imgfov_pc_velo = pc_velo[fov_inds,:]
+    fov_inds = (
+        (pts_2d[:, 0] < xmax)
+        & (pts_2d[:, 0] >= xmin)
+        & (pts_2d[:, 1] < ymax)
+        & (pts_2d[:, 1] >= ymin)
+    )
+    fov_inds = fov_inds & (pc_velo[:, 0] > clip_distance)
+    imgfov_pc_velo = pc_velo[fov_inds, :]
     if return_more:
         return imgfov_pc_velo, pts_2d, fov_inds
     else:
         return imgfov_pc_velo
 
-def get_lidar_index_in_image_fov(pc_velo, calib, xmin, ymin, xmax, ymax,
-                           return_more=False, clip_distance=2.0):
-    ''' Filter lidar points, keep those in image FOV '''
+
+def get_lidar_index_in_image_fov(
+    pc_velo, calib, xmin, ymin, xmax, ymax, return_more=False, clip_distance=2.0
+):
+    """ Filter lidar points, keep those in image FOV """
     pts_2d = calib.project_velo_to_image(pc_velo)
-    fov_inds = (pts_2d[:,0]<xmax) & (pts_2d[:,0]>=xmin) & \
-        (pts_2d[:,1]<ymax) & (pts_2d[:,1]>=ymin)
-    fov_inds = fov_inds & (pc_velo[:,0]>clip_distance)
+    fov_inds = (
+        (pts_2d[:, 0] < xmax)
+        & (pts_2d[:, 0] >= xmin)
+        & (pts_2d[:, 1] < ymax)
+        & (pts_2d[:, 1] >= ymin)
+    )
+    fov_inds = fov_inds & (pc_velo[:, 0] > clip_distance)
     return fov_inds
 
+
 def depth_region_pt3d(depth, obj):
     b = obj.box2d
-    #depth_region = depth[b[0]:b[2],b[2]:b[3],0]
-    pt3d=[]
-    #import pdb; pdb.set_trace()
-    for i in range(int(b[0]),int(b[2])):
-        for j in range(int(b[1]),int(b[3])):
-            pt3d.append([j,i,depth[j,i]])
+    # depth_region = depth[b[0]:b[2],b[2]:b[3],0]
+    pt3d = []
+    # import pdb; pdb.set_trace()
+    for i in range(int(b[0]), int(b[2])):
+        for j in range(int(b[1]), int(b[3])):
+            pt3d.append([j, i, depth[j, i]])
     return np.array(pt3d)
 
+
 def get_depth_pt3d(depth):
-    pt3d=[]
+    pt3d = []
     for i in range(depth.shape[0]):
         for j in range(depth.shape[1]):
             pt3d.append([i, j, depth[i, j]])
     return np.array(pt3d)
 
-def show_lidar_with_depth(pc_velo,
-                          objects,
-                          calib,
-                          fig,
-                          img_fov=False,
-                          img_width=None,
-                          img_height=None,
-                          objects_pred=None,
-                          depth=None,
-                          cam_img=None,
-                          constraint_box=False,
-                          pc_label=False,
-                          save=False):
-    ''' Show all LiDAR points.
-        Draw 3d box in LiDAR point cloud (in velo coord system) '''
+
+def show_lidar_with_depth(
+    pc_velo,
+    objects,
+    calib,
+    fig,
+    img_fov=False,
+    img_width=None,
+    img_height=None,
+    objects_pred=None,
+    depth=None,
+    cam_img=None,
+    constraint_box=False,
+    pc_label=False,
+    save=False,
+):
+    """ Show all LiDAR points.
+        Draw 3d box in LiDAR point cloud (in velo coord system) """
     from viz_util import draw_lidar_simple, draw_lidar, draw_gt_boxes3d
 
-    print(('All point num: ', pc_velo.shape[0]))
+    print(("All point num: ", pc_velo.shape[0]))
     if img_fov:
-        pc_velo_index = get_lidar_index_in_image_fov(pc_velo[:,:3], calib, 0, 0,
-            img_width, img_height)
-        pc_velo = pc_velo[pc_velo_index,:]
-        print(('FOV point num: ', pc_velo.shape))
-    print("pc_velo",pc_velo.shape)
+        pc_velo_index = get_lidar_index_in_image_fov(
+            pc_velo[:, :3], calib, 0, 0, img_width, img_height
+        )
+        pc_velo = pc_velo[pc_velo_index, :]
+        print(("FOV point num: ", pc_velo.shape))
+    print("pc_velo", pc_velo.shape)
     draw_lidar(pc_velo, fig=fig, pc_label=pc_label)
 
     # Draw depth
     if depth is not None:
         depth_pc_velo = calib.project_depth_to_velo(depth, constraint_box)
 
-        indensity = np.ones((depth_pc_velo.shape[0],1)) * 0.5
+        indensity = np.ones((depth_pc_velo.shape[0], 1)) * 0.5
         depth_pc_velo = np.hstack((depth_pc_velo, indensity))
-        print("depth_pc_velo:",depth_pc_velo.shape)
-        print("depth_pc_velo:",type(depth_pc_velo))
+        print("depth_pc_velo:", depth_pc_velo.shape)
+        print("depth_pc_velo:", type(depth_pc_velo))
         print(depth_pc_velo[:5])
-        draw_lidar(depth_pc_velo, fig=fig, pts_color=(1,1,1))
+        draw_lidar(depth_pc_velo, fig=fig, pts_color=(1, 1, 1))
 
         if save:
-            data_idx=0
+            data_idx = 0
             vely_dir = "data/obj/training/depth_pc"
-            save_filename = os.path.join(vely_dir, '%06d.bin'%(data_idx))
+            save_filename = os.path.join(vely_dir, "%06d.bin" % (data_idx))
             print(save_filename)
-            #np.save(save_filename+".npy", np.array(depth_pc_velo))
-            depth_pc_velo=depth_pc_velo.astype(np.float32)
+            # np.save(save_filename+".npy", np.array(depth_pc_velo))
+            depth_pc_velo = depth_pc_velo.astype(np.float32)
             depth_pc_velo.tofile(save_filename)
 
-
-    color=(0,1,0)
+    color = (0, 1, 0)
     for obj in objects:
-        if obj.type=='DontCare':continue
+        if obj.type == "DontCare":
+            continue
         # Draw 3d bounding box
         box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
         box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
@@ -348,9 +402,10 @@ def show_lidar_with_depth(pc_velo,
         draw_gt_boxes3d([box3d_pts_3d_velo], fig=fig, color=color)
 
     if objects_pred is not None:
-        color=(1,0,0)
+        color = (1, 0, 0)
         for obj in objects_pred:
-            if obj.type=='DontCare':continue
+            if obj.type == "DontCare":
+                continue
             # Draw 3d bounding box
             box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
             box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
@@ -360,83 +415,120 @@ def show_lidar_with_depth(pc_velo,
             # Draw heading arrow
             ori3d_pts_2d, ori3d_pts_3d = utils.compute_orientation_3d(obj, calib.P)
             ori3d_pts_3d_velo = calib.project_rect_to_velo(ori3d_pts_3d)
-            x1,y1,z1 = ori3d_pts_3d_velo[0,:]
-            x2,y2,z2 = ori3d_pts_3d_velo[1,:]
-            mlab.plot3d([x1, x2], [y1, y2], [z1,z2], color=color,
-                tube_radius=None, line_width=1, figure=fig)
+            x1, y1, z1 = ori3d_pts_3d_velo[0, :]
+            x2, y2, z2 = ori3d_pts_3d_velo[1, :]
+            mlab.plot3d(
+                [x1, x2],
+                [y1, y2],
+                [z1, z2],
+                color=color,
+                tube_radius=None,
+                line_width=1,
+                figure=fig,
+            )
     mlab.show(1)
 
-def save_depth0(data_idx, pc_velo, calib, img_fov, img_width, img_height, \
-               depth, constraint_box=False):
+
+def save_depth0(
+    data_idx,
+    pc_velo,
+    calib,
+    img_fov,
+    img_width,
+    img_height,
+    depth,
+    constraint_box=False,
+):
 
     if img_fov:
-        pc_velo_index = get_lidar_index_in_image_fov(pc_velo[:,:3], calib, 0, 0,
-            img_width, img_height)
-        pc_velo = pc_velo[pc_velo_index,:]
-        type = np.zeros((pc_velo.shape[0],1))
+        pc_velo_index = get_lidar_index_in_image_fov(
+            pc_velo[:, :3], calib, 0, 0, img_width, img_height
+        )
+        pc_velo = pc_velo[pc_velo_index, :]
+        type = np.zeros((pc_velo.shape[0], 1))
         pc_velo = np.hstack((pc_velo, type))
-        print(('FOV point num: ', pc_velo.shape))
+        print(("FOV point num: ", pc_velo.shape))
     # Draw depth
     if depth is not None:
         depth_pc_velo = calib.project_depth_to_velo(depth, constraint_box)
 
-        indensity = np.ones((depth_pc_velo.shape[0],1)) * 0.5
+        indensity = np.ones((depth_pc_velo.shape[0], 1)) * 0.5
         depth_pc_velo = np.hstack((depth_pc_velo, indensity))
 
-        type = np.ones((depth_pc_velo.shape[0],1))
+        type = np.ones((depth_pc_velo.shape[0], 1))
         depth_pc_velo = np.hstack((depth_pc_velo, type))
-        print("depth_pc_velo:",depth_pc_velo.shape)
-
+        print("depth_pc_velo:", depth_pc_velo.shape)
 
-        depth_pc = np.concatenate((pc_velo, depth_pc_velo),axis=0)
-        print("depth_pc:",depth_pc.shape)
+        depth_pc = np.concatenate((pc_velo, depth_pc_velo), axis=0)
+        print("depth_pc:", depth_pc.shape)
 
     vely_dir = "data/obj/training/depth_pc"
-    save_filename = os.path.join(vely_dir, '%06d.bin'%(data_idx))
+    save_filename = os.path.join(vely_dir, "%06d.bin" % (data_idx))
 
-    depth_pc=depth_pc.astype(np.float32)
+    depth_pc = depth_pc.astype(np.float32)
     depth_pc.tofile(save_filename)
 
-def save_depth(data_idx, pc_velo, calib, img_fov, img_width, img_height,
-               depth, constraint_box=False):
+
+def save_depth(
+    data_idx,
+    pc_velo,
+    calib,
+    img_fov,
+    img_width,
+    img_height,
+    depth,
+    constraint_box=False,
+):
 
     if depth is not None:
         depth_pc_velo = calib.project_depth_to_velo(depth, constraint_box)
 
-        indensity = np.ones((depth_pc_velo.shape[0],1)) * 0.5
+        indensity = np.ones((depth_pc_velo.shape[0], 1)) * 0.5
         depth_pc = np.hstack((depth_pc_velo, indensity))
 
-
-        print("depth_pc:",depth_pc.shape)
+        print("depth_pc:", depth_pc.shape)
 
     vely_dir = "data/obj/training/depth_pc"
-    save_filename = os.path.join(vely_dir, '%06d.bin'%(data_idx))
+    save_filename = os.path.join(vely_dir, "%06d.bin" % (data_idx))
 
-    depth_pc=depth_pc.astype(np.float32)
+    depth_pc = depth_pc.astype(np.float32)
     depth_pc.tofile(save_filename)
 
 
-def show_lidar_with_boxes(pc_velo, objects, calib, img_fov=False, img_width=None,
-        img_height=None, objects_pred=None, depth=None, cam_img=None):
-    ''' Show all LiDAR points.
-        Draw 3d box in LiDAR point cloud (in velo coord system) '''
-    if 'mlab' not in sys.modules: import mayavi.mlab as mlab
+def show_lidar_with_boxes(
+    pc_velo,
+    objects,
+    calib,
+    img_fov=False,
+    img_width=None,
+    img_height=None,
+    objects_pred=None,
+    depth=None,
+    cam_img=None,
+):
+    """ Show all LiDAR points.
+        Draw 3d box in LiDAR point cloud (in velo coord system) """
+    if "mlab" not in sys.modules:
+        import mayavi.mlab as mlab
     from viz_util import draw_lidar_simple, draw_lidar, draw_gt_boxes3d
 
-    print(('All point num: ', pc_velo.shape[0]))
-    fig = mlab.figure(figure=None, bgcolor=(0,0,0),
-        fgcolor=None, engine=None, size=(1000, 500))
+    print(("All point num: ", pc_velo.shape[0]))
+    fig = mlab.figure(
+        figure=None, bgcolor=(0, 0, 0), fgcolor=None, engine=None, size=(1000, 500)
+    )
     if img_fov:
-        pc_velo = get_lidar_in_image_fov(pc_velo[:,0:3], calib, 0, 0,
-            img_width, img_height)
-        print(('FOV point num: ', pc_velo.shape[0]))
-    print("pc_velo",pc_velo.shape)
+        pc_velo = get_lidar_in_image_fov(
+            pc_velo[:, 0:3], calib, 0, 0, img_width, img_height
+        )
+        print(("FOV point num: ", pc_velo.shape[0]))
+    print("pc_velo", pc_velo.shape)
     draw_lidar(pc_velo, fig=fig)
-    #pc_velo=pc_velo[:,0:3]
+    # pc_velo=pc_velo[:,0:3]
 
-    color=(0,1,0)
+    color = (0, 1, 0)
     for obj in objects:
-        if obj.type=='DontCare':continue
+        if obj.type == "DontCare":
+            continue
         # Draw 3d bounding box
         box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
         box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
@@ -447,30 +539,38 @@ def show_lidar_with_boxes(pc_velo, objects, calib, img_fov=False, img_width=None
 
         # Draw depth
         if depth is not None:
-            #import pdb; pdb.set_trace()
-            depth_pt3d =  depth_region_pt3d(depth, obj)
+            # import pdb; pdb.set_trace()
+            depth_pt3d = depth_region_pt3d(depth, obj)
             depth_UVDepth = np.zeros_like(depth_pt3d)
-            depth_UVDepth[:,0] = depth_pt3d[:,1]
-            depth_UVDepth[:,1] = depth_pt3d[:,0]
-            depth_UVDepth[:,2] = depth_pt3d[:,2]
-            print("depth_pt3d:",depth_UVDepth)
+            depth_UVDepth[:, 0] = depth_pt3d[:, 1]
+            depth_UVDepth[:, 1] = depth_pt3d[:, 0]
+            depth_UVDepth[:, 2] = depth_pt3d[:, 2]
+            print("depth_pt3d:", depth_UVDepth)
             dep_pc_velo = calib.project_image_to_velo(depth_UVDepth)
-            print("dep_pc_velo:",dep_pc_velo)
+            print("dep_pc_velo:", dep_pc_velo)
 
-            draw_lidar(dep_pc_velo, fig=fig, pts_color=(1,1,1))
+            draw_lidar(dep_pc_velo, fig=fig, pts_color=(1, 1, 1))
         #
 
         # Draw heading arrow
         ori3d_pts_2d, ori3d_pts_3d = utils.compute_orientation_3d(obj, calib.P)
         ori3d_pts_3d_velo = calib.project_rect_to_velo(ori3d_pts_3d)
-        x1,y1,z1 = ori3d_pts_3d_velo[0,:]
-        x2,y2,z2 = ori3d_pts_3d_velo[1,:]
-        mlab.plot3d([x1, x2], [y1, y2], [z1,z2], color=color,
-            tube_radius=None, line_width=1, figure=fig)
+        x1, y1, z1 = ori3d_pts_3d_velo[0, :]
+        x2, y2, z2 = ori3d_pts_3d_velo[1, :]
+        mlab.plot3d(
+            [x1, x2],
+            [y1, y2],
+            [z1, z2],
+            color=color,
+            tube_radius=None,
+            line_width=1,
+            figure=fig,
+        )
     if objects_pred is not None:
-        color=(1,0,0)
+        color = (1, 0, 0)
         for obj in objects_pred:
-            if obj.type=='DontCare':continue
+            if obj.type == "DontCare":
+                continue
             # Draw 3d bounding box
             box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
             box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
@@ -480,71 +580,94 @@ def show_lidar_with_boxes(pc_velo, objects, calib, img_fov=False, img_width=None
             # Draw heading arrow
             ori3d_pts_2d, ori3d_pts_3d = utils.compute_orientation_3d(obj, calib.P)
             ori3d_pts_3d_velo = calib.project_rect_to_velo(ori3d_pts_3d)
-            x1,y1,z1 = ori3d_pts_3d_velo[0,:]
-            x2,y2,z2 = ori3d_pts_3d_velo[1,:]
-            mlab.plot3d([x1, x2], [y1, y2], [z1,z2], color=color,
-                tube_radius=None, line_width=1, figure=fig)
+            x1, y1, z1 = ori3d_pts_3d_velo[0, :]
+            x2, y2, z2 = ori3d_pts_3d_velo[1, :]
+            mlab.plot3d(
+                [x1, x2],
+                [y1, y2],
+                [z1, z2],
+                color=color,
+                tube_radius=None,
+                line_width=1,
+                figure=fig,
+            )
     mlab.show(1)
 
+
 def box_min_max(box3d):
     box_min = np.min(box3d, axis=0)
     box_max = np.max(box3d, axis=0)
     return box_min, box_max
 
+
 def get_velo_whl(box3d, pc):
     bmin, bmax = box_min_max(box3d)
-    ind = np.where((pc[:,0]>=bmin[0]) & (pc[:,0]<=bmax[0]) \
-                 & (pc[:,1]>=bmin[1]) & (pc[:,1]<=bmax[1]) \
-                 & (pc[:,2]>=bmin[2]) & (pc[:,2]<=bmax[2]))[0]
-    #print(pc[ind,:])
-    if len(ind)>0:
-        vmin, vmax = box_min_max(pc[ind,:])
+    ind = np.where(
+        (pc[:, 0] >= bmin[0])
+        & (pc[:, 0] <= bmax[0])
+        & (pc[:, 1] >= bmin[1])
+        & (pc[:, 1] <= bmax[1])
+        & (pc[:, 2] >= bmin[2])
+        & (pc[:, 2] <= bmax[2])
+    )[0]
+    # print(pc[ind,:])
+    if len(ind) > 0:
+        vmin, vmax = box_min_max(pc[ind, :])
         return vmax - vmin
     else:
-        return 0,0,0,0
+        return 0, 0, 0, 0
+
 
 def stat_lidar_with_boxes(pc_velo, objects, calib):
-    ''' Show all LiDAR points.
-        Draw 3d box in LiDAR point cloud (in velo coord system) '''
+    """ Show all LiDAR points.
+        Draw 3d box in LiDAR point cloud (in velo coord system) """
 
-    #print(('All point num: ', pc_velo.shape[0]))
+    # print(('All point num: ', pc_velo.shape[0]))
 
-    #draw_lidar(pc_velo, fig=fig)
-    #color=(0,1,0)
+    # draw_lidar(pc_velo, fig=fig)
+    # color=(0,1,0)
     for obj in objects:
-        if obj.type=='DontCare':continue
+        if obj.type == "DontCare":
+            continue
         box3d_pts_2d, box3d_pts_3d = utils.compute_box_3d(obj, calib.P)
         box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
-        v_l, v_w, v_h,_ = get_velo_whl(box3d_pts_3d_velo, pc_velo)
-        print("%.4f %.4f %.4f %s"%(v_w, v_h, v_l, obj.type))
+        v_l, v_w, v_h, _ = get_velo_whl(box3d_pts_3d_velo, pc_velo)
+        print("%.4f %.4f %.4f %s" % (v_w, v_h, v_l, obj.type))
 
 
 def show_lidar_on_image(pc_velo, img, calib, img_width, img_height):
-    ''' Project LiDAR points to image '''
-    imgfov_pc_velo, pts_2d, fov_inds = get_lidar_in_image_fov(pc_velo,
-        calib, 0, 0, img_width, img_height, True)
-    imgfov_pts_2d = pts_2d[fov_inds,:]
+    """ Project LiDAR points to image """
+    imgfov_pc_velo, pts_2d, fov_inds = get_lidar_in_image_fov(
+        pc_velo, calib, 0, 0, img_width, img_height, True
+    )
+    imgfov_pts_2d = pts_2d[fov_inds, :]
     imgfov_pc_rect = calib.project_velo_to_rect(imgfov_pc_velo)
 
     import matplotlib.pyplot as plt
-    cmap = plt.cm.get_cmap('hsv', 256)
-    cmap = np.array([cmap(i) for i in range(256)])[:,:3]*255
+
+    cmap = plt.cm.get_cmap("hsv", 256)
+    cmap = np.array([cmap(i) for i in range(256)])[:, :3] * 255
 
     for i in range(imgfov_pts_2d.shape[0]):
-        depth = imgfov_pc_rect[i,2]
-        color = cmap[int(640.0/depth),:]
-        cv2.circle(img, (int(np.round(imgfov_pts_2d[i,0])),
-            int(np.round(imgfov_pts_2d[i,1]))),
-            2, color=tuple(color), thickness=-1)
+        depth = imgfov_pc_rect[i, 2]
+        color = cmap[int(640.0 / depth), :]
+        cv2.circle(
+            img,
+            (int(np.round(imgfov_pts_2d[i, 0])), int(np.round(imgfov_pts_2d[i, 1]))),
+            2,
+            color=tuple(color),
+            thickness=-1,
+        )
     cv2.imshow("projection", img)
     return img
 
+
 def show_lidar_topview_with_boxes(pc_velo, objects, calib, objects_pred=None):
-    ''' top_view image'''
-    #print('pc_velo shape: ',pc_velo.shape)
+    """ top_view image"""
+    # print('pc_velo shape: ',pc_velo.shape)
     top_view = utils.lidar_to_top(pc_velo)
     top_image = utils.draw_top_image(top_view)
-    print('top_image:', top_image.shape)
+    print("top_image:", top_image.shape)
     # gt
 
     def bbox3d(obj):
@@ -552,34 +675,41 @@ def bbox3d(obj):
         box3d_pts_3d_velo = calib.project_rect_to_velo(box3d_pts_3d)
         return box3d_pts_3d_velo
 
-    boxes3d = [bbox3d(obj) for obj in objects if obj.type!='DontCare']
+    boxes3d = [bbox3d(obj) for obj in objects if obj.type != "DontCare"]
     gt = np.array(boxes3d)
-    #print("box2d BV:",boxes3d)
-    lines = [ obj.type for obj in objects if obj.type!='DontCare' ]
-    top_image = utils.draw_box3d_on_top(top_image, gt, text_lables=lines, scores=None, thickness=1, is_gt=True)
+    # print("box2d BV:",boxes3d)
+    lines = [obj.type for obj in objects if obj.type != "DontCare"]
+    top_image = utils.draw_box3d_on_top(
+        top_image, gt, text_lables=lines, scores=None, thickness=1, is_gt=True
+    )
     # pred
     if objects_pred is not None:
-        boxes3d = [bbox3d(obj) for obj in objects_pred if obj.type!='DontCare']
+        boxes3d = [bbox3d(obj) for obj in objects_pred if obj.type != "DontCare"]
         gt = np.array(boxes3d)
-        lines = [ obj.type for obj in objects_pred if obj.type!='DontCare' ]
-        top_image = utils.draw_box3d_on_top(top_image, gt, text_lables=lines, scores=None, thickness=1, is_gt=False)
+        lines = [obj.type for obj in objects_pred if obj.type != "DontCare"]
+        top_image = utils.draw_box3d_on_top(
+            top_image, gt, text_lables=lines, scores=None, thickness=1, is_gt=False
+        )
 
     cv2.imshow("top_image", top_image)
 
+
 def dataset_viz(root_dir, args):
     dataset = kitti_object(root_dir, split=args.split, args=args)
     ## load 2d detection results
-    objects2ds = read_det_file('box2d.list')
+    objects2ds = read_det_file("box2d.list")
 
     if args.show_lidar_with_depth:
         import mayavi.mlab as mlab
-        fig = mlab.figure(figure=None, bgcolor=(0,0,0),
-                          fgcolor=None, engine=None, size=(1000, 500))
+
+        fig = mlab.figure(
+            figure=None, bgcolor=(0, 0, 0), fgcolor=None, engine=None, size=(1000, 500)
+        )
     for data_idx in range(len(dataset)):
-        if args.ind>0:
-            data_idx=args.ind
+        if args.ind > 0:
+            data_idx = args.ind
         # Load data from dataset
-        if args.split == 'training':
+        if args.split == "training":
             objects = dataset.get_label_objects(data_idx)
         else:
             objects = []
@@ -587,38 +717,38 @@ def dataset_viz(root_dir, args):
 
         objects_pred = None
         if args.pred:
-            #if not dataset.isexist_pred_objects(data_idx):
+            # if not dataset.isexist_pred_objects(data_idx):
             #    continue
             objects_pred = dataset.get_pred_objects(data_idx)
             if objects_pred == None:
                 continue
         if objects_pred == None:
             print("no pred file")
-            #objects_pred[0].print_object()
+            # objects_pred[0].print_object()
 
         n_vec = 4
         if args.pc_label:
             n_vec = 5
-            
-        dtype=np.float32
+
+        dtype = np.float32
         if args.dtype64:
-            dtype=np.float64
-        pc_velo = dataset.get_lidar(data_idx, dtype, n_vec)[:,0:n_vec]
-        calib   = dataset.get_calibration(data_idx)
-        img     = dataset.get_image(data_idx)
+            dtype = np.float64
+        pc_velo = dataset.get_lidar(data_idx, dtype, n_vec)[:, 0:n_vec]
+        calib = dataset.get_calibration(data_idx)
+        img = dataset.get_image(data_idx)
         img_height, img_width, img_channel = img.shape
-        print(data_idx, 'image shape: ', img.shape)
-        print(data_idx, 'velo  shape: ', pc_velo.shape)
+        print(data_idx, "image shape: ", img.shape)
+        print(data_idx, "velo  shape: ", pc_velo.shape)
         if args.depth:
             depth, is_exist = dataset.get_depth(data_idx)
-            print(data_idx, 'depth shape: ', depth.shape)
+            print(data_idx, "depth shape: ", depth.shape)
         else:
-            depth=None
+            depth = None
 
-        #depth = cv2.cvtColor(depth, cv2.COLOR_BGR2RGB)
-        #depth_height, depth_width, depth_channel = img.shape
+        # depth = cv2.cvtColor(depth, cv2.COLOR_BGR2RGB)
+        # depth_height, depth_width, depth_channel = img.shape
 
-        #print(('Image shape: ', img.shape))
+        # print(('Image shape: ', img.shape))
 
         if args.stat:
             stat_lidar_with_boxes(pc_velo, objects, calib)
@@ -626,106 +756,188 @@ def dataset_viz(root_dir, args):
         print("======== Objects in Ground Truth ========")
         n_obj = 0
         for obj in objects:
-            if obj.type != 'DontCare':
-                print("=== {} object ===".format(n_obj+1))
+            if obj.type != "DontCare":
+                print("=== {} object ===".format(n_obj + 1))
                 obj.print_object()
                 n_obj += 1
 
         # Draw 3d box in LiDAR point cloud
         if args.show_lidar_topview_with_boxes:
-           # Draw lidar top view
-           show_lidar_topview_with_boxes(pc_velo, objects, calib, objects_pred)
+            # Draw lidar top view
+            show_lidar_topview_with_boxes(pc_velo, objects, calib, objects_pred)
 
-        #show_image_with_boxes_3type(img, objects, calib, objects2d, data_idx, objects_pred)
+        # show_image_with_boxes_3type(img, objects, calib, objects2d, data_idx, objects_pred)
         if args.show_image_with_boxes:
             # Draw 2d and 3d boxes on image
             show_image_with_boxes(img, objects, calib, True, depth)
         if args.show_lidar_with_depth:
             # Draw 3d box in LiDAR point cloud
-            show_lidar_with_depth(pc_velo, objects, calib, fig, args.img_fov, img_width, img_height, \
-                 objects_pred, depth, img, constraint_box=args.const_box, save=args.save_depth, pc_label=args.pc_label)
-            #show_lidar_with_boxes(pc_velo, objects, calib, True, img_width, img_height, \
+            show_lidar_with_depth(
+                pc_velo,
+                objects,
+                calib,
+                fig,
+                args.img_fov,
+                img_width,
+                img_height,
+                objects_pred,
+                depth,
+                img,
+                constraint_box=args.const_box,
+                save=args.save_depth,
+                pc_label=args.pc_label,
+            )
+            # show_lidar_with_boxes(pc_velo, objects, calib, True, img_width, img_height, \
             #    objects_pred, depth, img)
         if args.show_lidar_on_image:
             # Show LiDAR points on image.
-            show_lidar_on_image(pc_velo[:,0:3], img, calib, img_width, img_height)
-        input_str=raw_input()
+            show_lidar_on_image(pc_velo[:, 0:3], img, calib, img_width, img_height)
+        input_str = raw_input()
 
         mlab.clf()
         if input_str == "killall":
             break
 
+
 def depth_to_lidar_format(root_dir, args):
     dataset = kitti_object(root_dir, split=args.split, args=args)
     for data_idx in range(len(dataset)):
         # Load data from dataset
 
-        pc_velo         = dataset.get_lidar(data_idx)[:,0:4]
-        calib           = dataset.get_calibration(data_idx)
+        pc_velo = dataset.get_lidar(data_idx)[:, 0:4]
+        calib = dataset.get_calibration(data_idx)
         depth, is_exist = dataset.get_depth(data_idx)
-        img             = dataset.get_image(data_idx)
+        img = dataset.get_image(data_idx)
         img_height, img_width, img_channel = img.shape
-        print(data_idx, 'image shape: ', img.shape)
-        print(data_idx, 'velo  shape: ', pc_velo.shape)
-        print(data_idx, 'depth shape: ', depth.shape)
-        #depth = cv2.cvtColor(depth, cv2.COLOR_BGR2RGB)
-        #depth_height, depth_width, depth_channel = img.shape
-
-        #print(('Image shape: ', img.shape))
-        save_depth(data_idx, pc_velo, calib, args.img_fov, img_width, img_height,
-                   depth, constraint_box=args.const_box)
+        print(data_idx, "image shape: ", img.shape)
+        print(data_idx, "velo  shape: ", pc_velo.shape)
+        print(data_idx, "depth shape: ", depth.shape)
+        # depth = cv2.cvtColor(depth, cv2.COLOR_BGR2RGB)
+        # depth_height, depth_width, depth_channel = img.shape
+
+        # print(('Image shape: ', img.shape))
+        save_depth(
+            data_idx,
+            pc_velo,
+            calib,
+            args.img_fov,
+            img_width,
+            img_height,
+            depth,
+            constraint_box=args.const_box,
+        )
         input_str = raw_input()
 
 
 def read_det_file(det_filename):
-    ''' Parse lines in 2D detection output files '''
-    det_id2str = {1:'Pedestrian', 2:'Car', 3:'Cyclist'}
-    objects={}
-    with open(det_filename, 'r') as f:
+    """ Parse lines in 2D detection output files """
+    det_id2str = {1: "Pedestrian", 2: "Car", 3: "Cyclist"}
+    objects = {}
+    with open(det_filename, "r") as f:
         for line in f.readlines():
             obj = utils.Object2d(line.rstrip())
             if obj.img_name not in objects.keys():
-                objects[obj.img_name]=[]
+                objects[obj.img_name] = []
             objects[obj.img_name].append(obj)
-        #objects = [utils.Object2d(line.rstrip()) for line in f.readlines()]
+        # objects = [utils.Object2d(line.rstrip()) for line in f.readlines()]
 
     return objects
 
-if __name__=='__main__':
+
+if __name__ == "__main__":
     import mayavi.mlab as mlab
     from viz_util import draw_lidar_simple, draw_lidar, draw_gt_boxes3d
 
-    parser = argparse.ArgumentParser(description='PyTorch Training RPN')
-    parser.add_argument('-d', '--dir', type=str, default="data/obj", metavar='N',
-                        help='input  (default: data/object)')
-    parser.add_argument('-i', '--ind', type=int, default=0, metavar='N',
-                        help='input  (default: data/object)')
-    parser.add_argument('-p','--pred', action='store_true', help='show predict results')
-    parser.add_argument('-s','--stat', action='store_true', help=' stat the w/h/l of point cloud in gt bbox')
-    parser.add_argument('--split', type=str,  default='training',
-                        help='use training split or testing split (default: training)')
-    parser.add_argument('-l','--lidar', type=str, default="velodyne", metavar='N',
-                        help='velodyne dir  (default: velodyne)')
-    parser.add_argument('-e','--depthdir', type=str, default="depth", metavar='N',
-                        help='depth dir  (default: depth)')
-    parser.add_argument('-r','--preddir', type=str, default="pred", metavar='N',
-                        help='predicted boxes  (default: pred)')
-    parser.add_argument('--gen_depth',  action='store_true', help='generate depth')
-    parser.add_argument('--vis',  action='store_true', help='show images')
-    parser.add_argument('--depth',  action='store_true', help='load depth')
-    parser.add_argument('--img_fov',  action='store_true', help='front view mapping')
-    parser.add_argument('--const_box',  action='store_true', help='constraint box')
-    parser.add_argument('--save_depth',  action='store_true', help='save depth into file')
-    parser.add_argument('--pc_label',  action='store_true', help='5-verctor lidar, pc with label')
-    parser.add_argument('--dtype64',  action='store_true', help='for float64 datatype, default float64')
-    
-    parser.add_argument('--show_lidar_on_image', action='store_true', help='project lidar on image')
-    parser.add_argument('--show_lidar_with_depth', action='store_true', help='--show_lidar, depth is supported')
-    parser.add_argument('--show_image_with_boxes', action='store_true', help='show lidar')
-    parser.add_argument('--show_lidar_topview_with_boxes', action='store_true', help='show lidar topview')
+    parser = argparse.ArgumentParser(description="PyTorch Training RPN")
+    parser.add_argument(
+        "-d",
+        "--dir",
+        type=str,
+        default="data/obj",
+        metavar="N",
+        help="input  (default: data/object)",
+    )
+    parser.add_argument(
+        "-i",
+        "--ind",
+        type=int,
+        default=0,
+        metavar="N",
+        help="input  (default: data/object)",
+    )
+    parser.add_argument(
+        "-p", "--pred", action="store_true", help="show predict results"
+    )
+    parser.add_argument(
+        "-s",
+        "--stat",
+        action="store_true",
+        help=" stat the w/h/l of point cloud in gt bbox",
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="training",
+        help="use training split or testing split (default: training)",
+    )
+    parser.add_argument(
+        "-l",
+        "--lidar",
+        type=str,
+        default="velodyne",
+        metavar="N",
+        help="velodyne dir  (default: velodyne)",
+    )
+    parser.add_argument(
+        "-e",
+        "--depthdir",
+        type=str,
+        default="depth",
+        metavar="N",
+        help="depth dir  (default: depth)",
+    )
+    parser.add_argument(
+        "-r",
+        "--preddir",
+        type=str,
+        default="pred",
+        metavar="N",
+        help="predicted boxes  (default: pred)",
+    )
+    parser.add_argument("--gen_depth", action="store_true", help="generate depth")
+    parser.add_argument("--vis", action="store_true", help="show images")
+    parser.add_argument("--depth", action="store_true", help="load depth")
+    parser.add_argument("--img_fov", action="store_true", help="front view mapping")
+    parser.add_argument("--const_box", action="store_true", help="constraint box")
+    parser.add_argument(
+        "--save_depth", action="store_true", help="save depth into file"
+    )
+    parser.add_argument(
+        "--pc_label", action="store_true", help="5-verctor lidar, pc with label"
+    )
+    parser.add_argument(
+        "--dtype64", action="store_true", help="for float64 datatype, default float64"
+    )
+
+    parser.add_argument(
+        "--show_lidar_on_image", action="store_true", help="project lidar on image"
+    )
+    parser.add_argument(
+        "--show_lidar_with_depth",
+        action="store_true",
+        help="--show_lidar, depth is supported",
+    )
+    parser.add_argument(
+        "--show_image_with_boxes", action="store_true", help="show lidar"
+    )
+    parser.add_argument(
+        "--show_lidar_topview_with_boxes",
+        action="store_true",
+        help="show lidar topview",
+    )
     args = parser.parse_args()
     if args.pred:
-        assert os.path.exists(args.dir+"/" + args.split + "/pred")
+        assert os.path.exists(args.dir + "/" + args.split + "/pred")
 
     if args.vis:
         dataset_viz(args.dir, args)
diff --git a/kitti_util.py b/kitti_util.py
index 179bc2e..227ec74 100644
--- a/kitti_util.py
+++ b/kitti_util.py
@@ -7,7 +7,7 @@
 
 import numpy as np
 import cv2
-import os,math
+import os, math
 from scipy.optimize import leastsq
 from PIL import Image
 
@@ -22,53 +22,60 @@
 TOP_Y_DIVISION = 0.2
 TOP_Z_DIVISION = 0.3
 
-cbox = np.array([[0,70.4],[-40,40],[-3,2]])
+cbox = np.array([[0, 70.4], [-40, 40], [-3, 2]])
+
 
 class Object2d(object):
-    ''' 2d object label '''
+    """ 2d object label """
+
     def __init__(self, label_file_line):
-        data = label_file_line.split(' ')
+        data = label_file_line.split(" ")
 
         # extract label, truncation, occlusion
-        self.img_name = int(data[0]) # 'Car', 'Pedestrian', ...
-        self.typeid = int(data[1]) # truncated pixel ratio [0..1]
+        self.img_name = int(data[0])  # 'Car', 'Pedestrian', ...
+        self.typeid = int(data[1])  # truncated pixel ratio [0..1]
         self.prob = float(data[2])
-        self.box2d = np.array([int(data[3]),int(data[4]),int(data[5]),int(data[6])])
-
-
+        self.box2d = np.array([int(data[3]), int(data[4]), int(data[5]), int(data[6])])
 
     def print_object(self):
-        print('img_name, typeid, prob: %s, %d, %f' % \
-            (self.img_name, self.typeid, self.prob))
-        print('2d bbox (x0,y0,x1,y1): %d, %d, %d, %d' % \
-            (self.box2d[0], self.box2d[1], self.box2d[2], self.box2d[3]))
+        print(
+            "img_name, typeid, prob: %s, %d, %f"
+            % (self.img_name, self.typeid, self.prob)
+        )
+        print(
+            "2d bbox (x0,y0,x1,y1): %d, %d, %d, %d"
+            % (self.box2d[0], self.box2d[1], self.box2d[2], self.box2d[3])
+        )
 
 
 class Object3d(object):
-    ''' 3d object label '''
+    """ 3d object label """
+
     def __init__(self, label_file_line):
-        data = label_file_line.split(' ')
+        data = label_file_line.split(" ")
         data[1:] = [float(x) for x in data[1:]]
 
         # extract label, truncation, occlusion
-        self.type = data[0] # 'Car', 'Pedestrian', ...
-        self.truncation = data[1] # truncated pixel ratio [0..1]
-        self.occlusion = int(data[2]) # 0=visible, 1=partly occluded, 2=fully occluded, 3=unknown
-        self.alpha = data[3] # object observation angle [-pi..pi]
+        self.type = data[0]  # 'Car', 'Pedestrian', ...
+        self.truncation = data[1]  # truncated pixel ratio [0..1]
+        self.occlusion = int(
+            data[2]
+        )  # 0=visible, 1=partly occluded, 2=fully occluded, 3=unknown
+        self.alpha = data[3]  # object observation angle [-pi..pi]
 
         # extract 2d bounding box in 0-based coordinates
-        self.xmin = data[4] # left
-        self.ymin = data[5] # top
-        self.xmax = data[6] # right
-        self.ymax = data[7] # bottom
-        self.box2d = np.array([self.xmin,self.ymin,self.xmax,self.ymax])
+        self.xmin = data[4]  # left
+        self.ymin = data[5]  # top
+        self.xmax = data[6]  # right
+        self.ymax = data[7]  # bottom
+        self.box2d = np.array([self.xmin, self.ymin, self.xmax, self.ymax])
 
         # extract 3d bounding box information
-        self.h = data[8] # box height
-        self.w = data[9] # box width
-        self.l = data[10] # box length (in meters)
-        self.t = (data[11],data[12],data[13]) # location (x,y,z) in camera coord.
-        self.ry = data[14] # yaw angle (around Y-axis in camera coordinates) [-pi..pi]
+        self.h = data[8]  # box height
+        self.w = data[9]  # box width
+        self.l = data[10]  # box length (in meters)
+        self.t = (data[11], data[12], data[13])  # location (x,y,z) in camera coord.
+        self.ry = data[14]  # yaw angle (around Y-axis in camera coordinates) [-pi..pi]
 
     def estimate_diffculty(self):
         """ Function that estimate difficulty to detect the object as defined in kitti website"""
@@ -77,27 +84,34 @@ def estimate_diffculty(self):
 
         if bb_height >= 40 and self.occlusion == 0 and self.truncation <= 0.15:
             return "Easy"
-        elif bb_height >= 25 and self.occlusion in [0,1] and self.truncation <= 0.30:
+        elif bb_height >= 25 and self.occlusion in [0, 1] and self.truncation <= 0.30:
             return "Moderate"
-        elif bb_height >= 25 and self.occlusion in [0,1,2] and self.truncation <= 0.50:
+        elif (
+            bb_height >= 25 and self.occlusion in [0, 1, 2] and self.truncation <= 0.50
+        ):
             return "Hard"
         else:
             return "Unknown"
 
     def print_object(self):
-        print('Type, truncation, occlusion, alpha: %s, %d, %d, %f' % \
-            (self.type, self.truncation, self.occlusion, self.alpha))
-        print('2d bbox (x0,y0,x1,y1): %f, %f, %f, %f' % \
-            (self.xmin, self.ymin, self.xmax, self.ymax))
-        print('3d bbox h,w,l: %f, %f, %f' % \
-            (self.h, self.w, self.l))
-        print('3d bbox location, ry: (%f, %f, %f), %f' % \
-            (self.t[0],self.t[1],self.t[2],self.ry))
-        print('Difficulty of estimation: {}'.format(self.estimate_diffculty()))
+        print(
+            "Type, truncation, occlusion, alpha: %s, %d, %d, %f"
+            % (self.type, self.truncation, self.occlusion, self.alpha)
+        )
+        print(
+            "2d bbox (x0,y0,x1,y1): %f, %f, %f, %f"
+            % (self.xmin, self.ymin, self.xmax, self.ymax)
+        )
+        print("3d bbox h,w,l: %f, %f, %f" % (self.h, self.w, self.l))
+        print(
+            "3d bbox location, ry: (%f, %f, %f), %f"
+            % (self.t[0], self.t[1], self.t[2], self.ry)
+        )
+        print("Difficulty of estimation: {}".format(self.estimate_diffculty()))
 
 
 class Calibration(object):
-    ''' Calibration matrices and utils
+    """ Calibration matrices and utils
         3d XYZ in <label>.txt are in rect camera coord.
         2d box xy are in image2 coord
         Points in <lidar>.bin are in Velodyne coord.
@@ -127,41 +141,43 @@ class Calibration(object):
         Ref (KITTI paper): http://www.cvlibs.net/publications/Geiger2013IJRR.pdf
 
         TODO(rqi): do matrix multiplication only once for each projection.
-    '''
+    """
+
     def __init__(self, calib_filepath, from_video=False):
         if from_video:
             calibs = self.read_calib_from_video(calib_filepath)
         else:
             calibs = self.read_calib_file(calib_filepath)
         # Projection matrix from rect camera coord to image2 coord
-        self.P = calibs['P2']
-        self.P = np.reshape(self.P, [3,4])
+        self.P = calibs["P2"]
+        self.P = np.reshape(self.P, [3, 4])
         # Rigid transform from Velodyne coord to reference camera coord
-        self.V2C = calibs['Tr_velo_to_cam']
-        self.V2C = np.reshape(self.V2C, [3,4])
+        self.V2C = calibs["Tr_velo_to_cam"]
+        self.V2C = np.reshape(self.V2C, [3, 4])
         self.C2V = inverse_rigid_trans(self.V2C)
         # Rotation from reference camera coord to rect camera coord
-        self.R0 = calibs['R0_rect']
-        self.R0 = np.reshape(self.R0,[3,3])
+        self.R0 = calibs["R0_rect"]
+        self.R0 = np.reshape(self.R0, [3, 3])
 
         # Camera intrinsics and extrinsics
-        self.c_u = self.P[0,2]
-        self.c_v = self.P[1,2]
-        self.f_u = self.P[0,0]
-        self.f_v = self.P[1,1]
-        self.b_x = self.P[0,3]/(-self.f_u) # relative
-        self.b_y = self.P[1,3]/(-self.f_v)
+        self.c_u = self.P[0, 2]
+        self.c_v = self.P[1, 2]
+        self.f_u = self.P[0, 0]
+        self.f_v = self.P[1, 1]
+        self.b_x = self.P[0, 3] / (-self.f_u)  # relative
+        self.b_y = self.P[1, 3] / (-self.f_v)
 
     def read_calib_file(self, filepath):
-        ''' Read in a calibration file and parse into a dictionary.
+        """ Read in a calibration file and parse into a dictionary.
         Ref: https://github.com/utiasSTARS/pykitti/blob/master/pykitti/utils.py
-        '''
+        """
         data = {}
-        with open(filepath, 'r') as f:
+        with open(filepath, "r") as f:
             for line in f.readlines():
                 line = line.rstrip()
-                if len(line)==0: continue
-                key, value = line.split(':', 1)
+                if len(line) == 0:
+                    continue
+                key, value = line.split(":", 1)
                 # The only non-float values in these files are dates, which
                 # we don't care about anyway
                 try:
@@ -172,51 +188,55 @@ def read_calib_file(self, filepath):
         return data
 
     def read_calib_from_video(self, calib_root_dir):
-        ''' Read calibration for camera 2 from video calib files.
+        """ Read calibration for camera 2 from video calib files.
             there are calib_cam_to_cam and calib_velo_to_cam under the calib_root_dir
-        '''
+        """
         data = {}
-        cam2cam = self.read_calib_file(os.path.join(calib_root_dir, 'calib_cam_to_cam.txt'))
-        velo2cam = self.read_calib_file(os.path.join(calib_root_dir, 'calib_velo_to_cam.txt'))
-        Tr_velo_to_cam = np.zeros((3,4))
-        Tr_velo_to_cam[0:3,0:3] = np.reshape(velo2cam['R'], [3,3])
-        Tr_velo_to_cam[:,3] = velo2cam['T']
-        data['Tr_velo_to_cam'] = np.reshape(Tr_velo_to_cam, [12])
-        data['R0_rect'] = cam2cam['R_rect_00']
-        data['P2'] = cam2cam['P_rect_02']
+        cam2cam = self.read_calib_file(
+            os.path.join(calib_root_dir, "calib_cam_to_cam.txt")
+        )
+        velo2cam = self.read_calib_file(
+            os.path.join(calib_root_dir, "calib_velo_to_cam.txt")
+        )
+        Tr_velo_to_cam = np.zeros((3, 4))
+        Tr_velo_to_cam[0:3, 0:3] = np.reshape(velo2cam["R"], [3, 3])
+        Tr_velo_to_cam[:, 3] = velo2cam["T"]
+        data["Tr_velo_to_cam"] = np.reshape(Tr_velo_to_cam, [12])
+        data["R0_rect"] = cam2cam["R_rect_00"]
+        data["P2"] = cam2cam["P_rect_02"]
         return data
 
     def cart2hom(self, pts_3d):
-        ''' Input: nx3 points in Cartesian
+        """ Input: nx3 points in Cartesian
             Oupput: nx4 points in Homogeneous by pending 1
-        '''
+        """
         n = pts_3d.shape[0]
-        pts_3d_hom = np.hstack((pts_3d, np.ones((n,1))))
+        pts_3d_hom = np.hstack((pts_3d, np.ones((n, 1))))
         return pts_3d_hom
 
     # ===========================
     # ------- 3d to 3d ----------
     # ===========================
     def project_velo_to_ref(self, pts_3d_velo):
-        pts_3d_velo = self.cart2hom(pts_3d_velo) # nx4
+        pts_3d_velo = self.cart2hom(pts_3d_velo)  # nx4
         return np.dot(pts_3d_velo, np.transpose(self.V2C))
 
     def project_ref_to_velo(self, pts_3d_ref):
-        pts_3d_ref = self.cart2hom(pts_3d_ref) # nx4
+        pts_3d_ref = self.cart2hom(pts_3d_ref)  # nx4
         return np.dot(pts_3d_ref, np.transpose(self.C2V))
 
     def project_rect_to_ref(self, pts_3d_rect):
-        ''' Input and Output are nx3 points '''
+        """ Input and Output are nx3 points """
         return np.transpose(np.dot(np.linalg.inv(self.R0), np.transpose(pts_3d_rect)))
 
     def project_ref_to_rect(self, pts_3d_ref):
-        ''' Input and Output are nx3 points '''
+        """ Input and Output are nx3 points """
         return np.transpose(np.dot(self.R0, np.transpose(pts_3d_ref)))
 
     def project_rect_to_velo(self, pts_3d_rect):
-        ''' Input: nx3 points in rect camera coord.
+        """ Input: nx3 points in rect camera coord.
             Output: nx3 points in velodyne coord.
-        '''
+        """
         pts_3d_ref = self.project_rect_to_ref(pts_3d_rect)
         return self.project_ref_to_velo(pts_3d_ref)
 
@@ -228,37 +248,37 @@ def project_velo_to_rect(self, pts_3d_velo):
     # ------- 3d to 2d ----------
     # ===========================
     def project_rect_to_image(self, pts_3d_rect):
-        ''' Input: nx3 points in rect camera coord.
+        """ Input: nx3 points in rect camera coord.
             Output: nx2 points in image2 coord.
-        '''
+        """
         pts_3d_rect = self.cart2hom(pts_3d_rect)
-        pts_2d = np.dot(pts_3d_rect, np.transpose(self.P)) # nx3
-        pts_2d[:,0] /= pts_2d[:,2]
-        pts_2d[:,1] /= pts_2d[:,2]
-        return pts_2d[:,0:2]
+        pts_2d = np.dot(pts_3d_rect, np.transpose(self.P))  # nx3
+        pts_2d[:, 0] /= pts_2d[:, 2]
+        pts_2d[:, 1] /= pts_2d[:, 2]
+        return pts_2d[:, 0:2]
 
     def project_velo_to_image(self, pts_3d_velo):
-        ''' Input: nx3 points in velodyne coord.
+        """ Input: nx3 points in velodyne coord.
             Output: nx2 points in image2 coord.
-        '''
+        """
         pts_3d_rect = self.project_velo_to_rect(pts_3d_velo)
         return self.project_rect_to_image(pts_3d_rect)
 
     def project_8p_to_4p(self, pts_2d):
-        x0 = np.min(pts_2d[:,0])
-        x1 = np.max(pts_2d[:,0])
-        y0 = np.min(pts_2d[:,1])
-        y1 = np.max(pts_2d[:,1])
-        x0 = max(0,x0)
-        #x1 = min(x1, proj.image_width)
-        y0 = max(0,y0)
-        #y1 = min(y1, proj.image_height)
+        x0 = np.min(pts_2d[:, 0])
+        x1 = np.max(pts_2d[:, 0])
+        y0 = np.min(pts_2d[:, 1])
+        y1 = np.max(pts_2d[:, 1])
+        x0 = max(0, x0)
+        # x1 = min(x1, proj.image_width)
+        y0 = max(0, y0)
+        # y1 = min(y1, proj.image_height)
         return np.array([x0, y0, x1, y1])
 
     def project_velo_to_4p(self, pts_3d_velo):
-        ''' Input: nx3 points in velodyne coord.
+        """ Input: nx3 points in velodyne coord.
             Output: 4 points in image2 coord.
-        '''
+        """
         pts_2d_velo = self.project_velo_to_image(pts_3d_velo)
         return self.project_8p_to_4p(pts_2d_velo)
 
@@ -266,45 +286,47 @@ def project_velo_to_4p(self, pts_3d_velo):
     # ------- 2d to 3d ----------
     # ===========================
     def project_image_to_rect(self, uv_depth):
-        ''' Input: nx3 first two channels are uv, 3rd channel
+        """ Input: nx3 first two channels are uv, 3rd channel
                    is depth in rect camera coord.
             Output: nx3 points in rect camera coord.
-        '''
+        """
         n = uv_depth.shape[0]
-        x = ((uv_depth[:,0]-self.c_u)*uv_depth[:,2])/self.f_u + self.b_x
-        y = ((uv_depth[:,1]-self.c_v)*uv_depth[:,2])/self.f_v + self.b_y
-        pts_3d_rect = np.zeros((n,3))
-        pts_3d_rect[:,0] = x
-        pts_3d_rect[:,1] = y
-        pts_3d_rect[:,2] = uv_depth[:,2]
+        x = ((uv_depth[:, 0] - self.c_u) * uv_depth[:, 2]) / self.f_u + self.b_x
+        y = ((uv_depth[:, 1] - self.c_v) * uv_depth[:, 2]) / self.f_v + self.b_y
+        pts_3d_rect = np.zeros((n, 3))
+        pts_3d_rect[:, 0] = x
+        pts_3d_rect[:, 1] = y
+        pts_3d_rect[:, 2] = uv_depth[:, 2]
         return pts_3d_rect
 
     def project_image_to_velo(self, uv_depth):
         pts_3d_rect = self.project_image_to_rect(uv_depth)
         return self.project_rect_to_velo(pts_3d_rect)
 
-
     def project_depth_to_velo(self, depth, constraint_box=True):
-        depth_pt3d =  get_depth_pt3d(depth)
+        depth_pt3d = get_depth_pt3d(depth)
         depth_UVDepth = np.zeros_like(depth_pt3d)
-        depth_UVDepth[:,0] = depth_pt3d[:,1]
-        depth_UVDepth[:,1] = depth_pt3d[:,0]
-        depth_UVDepth[:,2] = depth_pt3d[:,2]
-        #print("depth_pt3d:",depth_UVDepth.shape)
+        depth_UVDepth[:, 0] = depth_pt3d[:, 1]
+        depth_UVDepth[:, 1] = depth_pt3d[:, 0]
+        depth_UVDepth[:, 2] = depth_pt3d[:, 2]
+        # print("depth_pt3d:",depth_UVDepth.shape)
         depth_pc_velo = self.project_image_to_velo(depth_UVDepth)
-        #print("dep_pc_velo:",depth_pc_velo.shape)
+        # print("dep_pc_velo:",depth_pc_velo.shape)
         if constraint_box:
-            depth_box_fov_inds = (depth_pc_velo[:,0]< cbox[0][1] ) & \
-                (depth_pc_velo[:,0]>= cbox[0][0] ) & \
-                (depth_pc_velo[:,1]<  cbox[1][1]) & \
-                (depth_pc_velo[:,1]>= cbox[1][0]) & \
-                (depth_pc_velo[:,2]<  cbox[2][1]) & \
-                (depth_pc_velo[:,2]>= cbox[2][0])
-            depth_pc_velo=depth_pc_velo[depth_box_fov_inds]
+            depth_box_fov_inds = (
+                (depth_pc_velo[:, 0] < cbox[0][1])
+                & (depth_pc_velo[:, 0] >= cbox[0][0])
+                & (depth_pc_velo[:, 1] < cbox[1][1])
+                & (depth_pc_velo[:, 1] >= cbox[1][0])
+                & (depth_pc_velo[:, 2] < cbox[2][1])
+                & (depth_pc_velo[:, 2] >= cbox[2][0])
+            )
+            depth_pc_velo = depth_pc_velo[depth_box_fov_inds]
         return depth_pc_velo
 
+
 def get_depth_pt3d(depth):
-    pt3d=[]
+    pt3d = []
     for i in range(depth.shape[0]):
         for j in range(depth.shape[1]):
             pt3d.append([i, j, depth[i, j]])
@@ -312,167 +334,170 @@ def get_depth_pt3d(depth):
 
 
 def rotx(t):
-    ''' 3D Rotation about the x-axis. '''
+    """ 3D Rotation about the x-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[1,  0,  0],
-                     [0,  c, -s],
-                     [0,  s,  c]])
+    return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])
 
 
 def roty(t):
-    ''' Rotation about the y-axis. '''
+    """ Rotation about the y-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[c,  0,  s],
-                     [0,  1,  0],
-                     [-s, 0,  c]])
+    return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])
 
 
 def rotz(t):
-    ''' Rotation about the z-axis. '''
+    """ Rotation about the z-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[c, -s,  0],
-                     [s,  c,  0],
-                     [0,  0,  1]])
+    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
 
 
 def transform_from_rot_trans(R, t):
-    ''' Transforation matrix from rotation matrix and translation vector. '''
+    """ Transforation matrix from rotation matrix and translation vector. """
     R = R.reshape(3, 3)
     t = t.reshape(3, 1)
     return np.vstack((np.hstack([R, t]), [0, 0, 0, 1]))
 
 
 def inverse_rigid_trans(Tr):
-    ''' Inverse a rigid body transform matrix (3x4 as [R|t])
+    """ Inverse a rigid body transform matrix (3x4 as [R|t])
         [R'|-R't; 0|1]
-    '''
-    inv_Tr = np.zeros_like(Tr) # 3x4
-    inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])
-    inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])
+    """
+    inv_Tr = np.zeros_like(Tr)  # 3x4
+    inv_Tr[0:3, 0:3] = np.transpose(Tr[0:3, 0:3])
+    inv_Tr[0:3, 3] = np.dot(-np.transpose(Tr[0:3, 0:3]), Tr[0:3, 3])
     return inv_Tr
 
+
 def read_label(label_filename):
     lines = [line.rstrip() for line in open(label_filename)]
     objects = [Object3d(line) for line in lines]
     return objects
 
+
 def load_image(img_filename):
     return cv2.imread(img_filename)
 
+
 def load_depth_v(img_filename):
-    #return cv2.imread(img_filename)
+    # return cv2.imread(img_filename)
     disp_img = cv2.imread(img_filename, cv2.IMREAD_UNCHANGED)
     disp_img = disp_img.astype(np.float)
     return disp_img / 256.0
+
+
 def load_depth0(img_filename):
-    #return cv2.imread(img_filename)
+    # return cv2.imread(img_filename)
     depth_img = np.array(Image.open(img_filename), dtype=int)
 
-    depth_img = depth_img.astype(np.float)/ 256.0
+    depth_img = depth_img.astype(np.float) / 256.0
 
     return depth_img
+
+
 def load_depth(img_filename):
     isexist = True
     disp_img = cv2.imread(img_filename, cv2.IMREAD_UNCHANGED)
     if disp_img is None:
         isexist = False
-        disp_img =np.zeros((370,1224))
+        disp_img = np.zeros((370, 1224))
     else:
         disp_img = disp_img.astype(np.float)
     return disp_img / 256.0, isexist
 
+
 def load_velo_scan(velo_filename, dtype=np.float32, n_vec=4):
     scan = np.fromfile(velo_filename, dtype=dtype)
     scan = scan.reshape((-1, n_vec))
     return scan
 
-def lidar_to_top_coords(x,y,z=None):
+
+def lidar_to_top_coords(x, y, z=None):
     if 0:
-        return x,y
+        return x, y
     else:
-       #print("TOP_X_MAX-TOP_X_MIN:",TOP_X_MAX,TOP_X_MIN)
-        X0, Xn = 0, int((TOP_X_MAX-TOP_X_MIN)//TOP_X_DIVISION)+1
-        Y0, Yn = 0, int((TOP_Y_MAX-TOP_Y_MIN)//TOP_Y_DIVISION)+1
-        xx = Yn-int((y-TOP_Y_MIN)//TOP_Y_DIVISION)
-        yy = Xn-int((x-TOP_X_MIN)//TOP_X_DIVISION)
+        # print("TOP_X_MAX-TOP_X_MIN:",TOP_X_MAX,TOP_X_MIN)
+        X0, Xn = 0, int((TOP_X_MAX - TOP_X_MIN) // TOP_X_DIVISION) + 1
+        Y0, Yn = 0, int((TOP_Y_MAX - TOP_Y_MIN) // TOP_Y_DIVISION) + 1
+        xx = Yn - int((y - TOP_Y_MIN) // TOP_Y_DIVISION)
+        yy = Xn - int((x - TOP_X_MIN) // TOP_X_DIVISION)
+
+        return xx, yy
 
-        return xx,yy
 
 def lidar_to_top(lidar):
 
-    idx = np.where (lidar[:,0]>TOP_X_MIN)
+    idx = np.where(lidar[:, 0] > TOP_X_MIN)
     lidar = lidar[idx]
-    idx = np.where (lidar[:,0]<TOP_X_MAX)
+    idx = np.where(lidar[:, 0] < TOP_X_MAX)
     lidar = lidar[idx]
 
-    idx = np.where (lidar[:,1]>TOP_Y_MIN)
+    idx = np.where(lidar[:, 1] > TOP_Y_MIN)
     lidar = lidar[idx]
-    idx = np.where (lidar[:,1]<TOP_Y_MAX)
+    idx = np.where(lidar[:, 1] < TOP_Y_MAX)
     lidar = lidar[idx]
 
-    idx = np.where (lidar[:,2]>TOP_Z_MIN)
+    idx = np.where(lidar[:, 2] > TOP_Z_MIN)
     lidar = lidar[idx]
-    idx = np.where (lidar[:,2]<TOP_Z_MAX)
+    idx = np.where(lidar[:, 2] < TOP_Z_MAX)
     lidar = lidar[idx]
 
-
-
-    pxs=lidar[:,0]
-    pys=lidar[:,1]
-    pzs=lidar[:,2]
-    prs=lidar[:,3]
-    qxs=((pxs-TOP_X_MIN)//TOP_X_DIVISION).astype(np.int32)
-    qys=((pys-TOP_Y_MIN)//TOP_Y_DIVISION).astype(np.int32)
-    #qzs=((pzs-TOP_Z_MIN)//TOP_Z_DIVISION).astype(np.int32)
-    qzs=(pzs-TOP_Z_MIN)/TOP_Z_DIVISION
-    quantized = np.dstack((qxs,qys,qzs,prs)).squeeze()
-
-    X0, Xn = 0, int((TOP_X_MAX-TOP_X_MIN)//TOP_X_DIVISION)+1
-    Y0, Yn = 0, int((TOP_Y_MAX-TOP_Y_MIN)//TOP_Y_DIVISION)+1
-    Z0, Zn = 0, int((TOP_Z_MAX-TOP_Z_MIN)/TOP_Z_DIVISION)
-    height  = Xn - X0
-    width   = Yn - Y0
-    channel = Zn - Z0  + 2
+    pxs = lidar[:, 0]
+    pys = lidar[:, 1]
+    pzs = lidar[:, 2]
+    prs = lidar[:, 3]
+    qxs = ((pxs - TOP_X_MIN) // TOP_X_DIVISION).astype(np.int32)
+    qys = ((pys - TOP_Y_MIN) // TOP_Y_DIVISION).astype(np.int32)
+    # qzs=((pzs-TOP_Z_MIN)//TOP_Z_DIVISION).astype(np.int32)
+    qzs = (pzs - TOP_Z_MIN) / TOP_Z_DIVISION
+    quantized = np.dstack((qxs, qys, qzs, prs)).squeeze()
+
+    X0, Xn = 0, int((TOP_X_MAX - TOP_X_MIN) // TOP_X_DIVISION) + 1
+    Y0, Yn = 0, int((TOP_Y_MAX - TOP_Y_MIN) // TOP_Y_DIVISION) + 1
+    Z0, Zn = 0, int((TOP_Z_MAX - TOP_Z_MIN) / TOP_Z_DIVISION)
+    height = Xn - X0
+    width = Yn - Y0
+    channel = Zn - Z0 + 2
     # print('height,width,channel=%d,%d,%d'%(height,width,channel))
-    top = np.zeros(shape=(height,width,channel), dtype=np.float32)
-
+    top = np.zeros(shape=(height, width, channel), dtype=np.float32)
 
     # histogram = Bin(channel, 0, Zn, "z", Bin(height, 0, Yn, "y", Bin(width, 0, Xn, "x", Maximize("intensity"))))
     # histogram.fill.numpy({"x": qxs, "y": qys, "z": qzs, "intensity": prs})
 
-    if 1:  #new method
+    if 1:  # new method
         for x in range(Xn):
-            ix  = np.where(quantized[:,0]==x)
+            ix = np.where(quantized[:, 0] == x)
             quantized_x = quantized[ix]
-            if len(quantized_x) == 0 : continue
+            if len(quantized_x) == 0:
+                continue
             yy = -x
 
             for y in range(Yn):
-                iy  = np.where(quantized_x[:,1]==y)
+                iy = np.where(quantized_x[:, 1] == y)
                 quantized_xy = quantized_x[iy]
                 count = len(quantized_xy)
-                if  count==0 : continue
+                if count == 0:
+                    continue
                 xx = -y
 
-                top[yy,xx,Zn+1] = min(1, np.log(count+1)/math.log(32))
-                max_height_point = np.argmax(quantized_xy[:,2])
-                top[yy,xx,Zn]=quantized_xy[max_height_point, 3]
+                top[yy, xx, Zn + 1] = min(1, np.log(count + 1) / math.log(32))
+                max_height_point = np.argmax(quantized_xy[:, 2])
+                top[yy, xx, Zn] = quantized_xy[max_height_point, 3]
 
                 for z in range(Zn):
-                    iz = np.where ((quantized_xy[:,2]>=z) & (quantized_xy[:,2]<=z+1))
+                    iz = np.where(
+                        (quantized_xy[:, 2] >= z) & (quantized_xy[:, 2] <= z + 1)
+                    )
                     quantized_xyz = quantized_xy[iz]
-                    if len(quantized_xyz) == 0 : continue
+                    if len(quantized_xyz) == 0:
+                        continue
                     zz = z
 
-                    #height per slice
-                    max_height = max(0,np.max(quantized_xyz[:,2])-z)
-                    top[yy,xx,zz]=max_height
-
-
-
+                    # height per slice
+                    max_height = max(0, np.max(quantized_xyz[:, 2]) - z)
+                    top[yy, xx, zz] = max_height
 
     # if 0: #unprocess
     #     top_image = np.zeros((height,width,3),dtype=np.float32)
@@ -487,69 +512,74 @@ def lidar_to_top(lidar):
     #     top_image = top_image/max_value *255
     #     top_image=top_image.astype(dtype=np.uint8)
 
-
     return top
 
-MATRIX_Mt = np.array([[  2.34773698e-04,   1.04494074e-02,   9.99945389e-01,  0.00000000e+00],
-                  [ -9.99944155e-01,   1.05653536e-02,   1.24365378e-04,  0.00000000e+00],
-                  [ -1.05634778e-02,  -9.99889574e-01,   1.04513030e-02,  0.00000000e+00],
-                  [  5.93721868e-02,  -7.51087914e-02,  -2.72132796e-01,  1.00000000e+00]])
 
-MATRIX_Kt = np.array([[ 721.5377,    0.    ,    0.    ],
-                  [   0.    ,  721.5377,    0.    ],
-                  [ 609.5593,  172.854 ,    1.    ]])
+MATRIX_Mt = np.array(
+    [
+        [2.34773698e-04, 1.04494074e-02, 9.99945389e-01, 0.00000000e00],
+        [-9.99944155e-01, 1.05653536e-02, 1.24365378e-04, 0.00000000e00],
+        [-1.05634778e-02, -9.99889574e-01, 1.04513030e-02, 0.00000000e00],
+        [5.93721868e-02, -7.51087914e-02, -2.72132796e-01, 1.00000000e00],
+    ]
+)
+
+MATRIX_Kt = np.array(
+    [[721.5377, 0.0, 0.0], [0.0, 721.5377, 0.0], [609.5593, 172.854, 1.0]]
+)
+
 
 def box3d_to_rgb_box00(box3d):
 
-    #box3d = boxes3d[n]
-    Ps = np.hstack(( box3d, np.ones((8,1))) )
-    Qs = np.matmul(Ps,MATRIX_Mt)
-    Qs = Qs[:,0:3]
-    qs = np.matmul(Qs,MATRIX_Kt)
-    zs = qs[:,2].reshape(8,1)
-    qs = (qs/zs)
+    # box3d = boxes3d[n]
+    Ps = np.hstack((box3d, np.ones((8, 1))))
+    Qs = np.matmul(Ps, MATRIX_Mt)
+    Qs = Qs[:, 0:3]
+    qs = np.matmul(Qs, MATRIX_Kt)
+    zs = qs[:, 2].reshape(8, 1)
+    qs = qs / zs
 
-    return qs[:,0:2]
+    return qs[:, 0:2]
 
 
 def box3d_to_rgb_box0000(boxes3d, Mt=None, Kt=None):
-    #if (cfg.DATA_SETS_TYPE == 'kitti'):
-    if Mt is None: Mt = np.array(MATRIX_Mt)
-    if Kt is None: Kt = np.array(MATRIX_Kt)
-
-    num  = len(boxes3d)
-    projections = np.zeros((num,8,2),  dtype=np.int32)
+    # if (cfg.DATA_SETS_TYPE == 'kitti'):
+    if Mt is None:
+        Mt = np.array(MATRIX_Mt)
+    if Kt is None:
+        Kt = np.array(MATRIX_Kt)
+
+    num = len(boxes3d)
+    projections = np.zeros((num, 8, 2), dtype=np.int32)
     for n in range(num):
         box3d = boxes3d[n]
-        Ps = np.hstack(( box3d, np.ones((8,1))) )
-        Qs = np.matmul(Ps,Mt)
-        Qs = Qs[:,0:3]
-        qs = np.matmul(Qs,Kt)
-        zs = qs[:,2].reshape(8,1)
-        qs = (qs/zs)
-        #pts_3d=project_to_image(qs[:,0:2], P)
-        projections[n] = qs[:,0:2]
-        #projections[n] = proj3d_to_2d(qs[:,0:2])
-        #projections[n] = pts_3d
+        Ps = np.hstack((box3d, np.ones((8, 1))))
+        Qs = np.matmul(Ps, Mt)
+        Qs = Qs[:, 0:3]
+        qs = np.matmul(Qs, Kt)
+        zs = qs[:, 2].reshape(8, 1)
+        qs = qs / zs
+        # pts_3d=project_to_image(qs[:,0:2], P)
+        projections[n] = qs[:, 0:2]
+        # projections[n] = proj3d_to_2d(qs[:,0:2])
+        # projections[n] = pts_3d
     return projections
 
 
 def proj3d_to_2d(rgbpoint):
-    x0 = np.min(rgbpoint[:,0])
-    x1 = np.max(rgbpoint[:,0])
-    y0 = np.min(rgbpoint[:,1])
-    y1 = np.max(rgbpoint[:,1])
-    #x0 = max(0,x0)
-    #x1 = min(x1, proj.image_width)
-    #y0 = max(0,y0)
-    #y1 = min(y1, proj.image_height)
+    x0 = np.min(rgbpoint[:, 0])
+    x1 = np.max(rgbpoint[:, 0])
+    y0 = np.min(rgbpoint[:, 1])
+    y1 = np.max(rgbpoint[:, 1])
+    # x0 = max(0,x0)
+    # x1 = min(x1, proj.image_width)
+    # y0 = max(0,y0)
+    # y1 = min(y1, proj.image_height)
     return np.array([x0, y0, x1, y1])
 
 
-
-
 def project_to_image(pts_3d, P):
-    ''' Project 3d points to image plane.
+    """ Project 3d points to image plane.
 
     Usage: pts_2d = projectToImage(pts_3d, P)
       input: pts_3d: nx3 matrix
@@ -561,85 +591,86 @@ def project_to_image(pts_3d, P):
 
       <=> pts_3d_extended(nx4) dot P'(4x3) = projected_pts_2d(nx3)
           => normalize projected_pts_2d(nx2)
-    '''
+    """
     n = pts_3d.shape[0]
-    pts_3d_extend = np.hstack((pts_3d, np.ones((n,1))))
-    #print(('pts_3d_extend shape: ', pts_3d_extend.shape))
-    pts_2d = np.dot(pts_3d_extend, np.transpose(P)) # nx3
-    pts_2d[:,0] /= pts_2d[:,2]
-    pts_2d[:,1] /= pts_2d[:,2]
-    return pts_2d[:,0:2]
+    pts_3d_extend = np.hstack((pts_3d, np.ones((n, 1))))
+    # print(('pts_3d_extend shape: ', pts_3d_extend.shape))
+    pts_2d = np.dot(pts_3d_extend, np.transpose(P))  # nx3
+    pts_2d[:, 0] /= pts_2d[:, 2]
+    pts_2d[:, 1] /= pts_2d[:, 2]
+    return pts_2d[:, 0:2]
 
 
 def compute_box_3d(obj, P):
-    ''' Takes an object and a projection matrix (P) and projects the 3d
+    """ Takes an object and a projection matrix (P) and projects the 3d
         bounding box into the image plane.
         Returns:
             corners_2d: (8,2) array in left image coord.
             corners_3d: (8,3) array in in rect camera coord.
-    '''
+    """
     # compute rotational matrix around yaw axis
     R = roty(obj.ry)
 
     # 3d bounding box dimensions
-    l = obj.l;
-    w = obj.w;
-    h = obj.h;
+    l = obj.l
+    w = obj.w
+    h = obj.h
 
     # 3d bounding box corners
-    x_corners = [l/2,l/2,-l/2,-l/2,l/2,l/2,-l/2,-l/2];
-    y_corners = [0,0,0,0,-h,-h,-h,-h];
-    z_corners = [w/2,-w/2,-w/2,w/2,w/2,-w/2,-w/2,w/2];
+    x_corners = [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2]
+    y_corners = [0, 0, 0, 0, -h, -h, -h, -h]
+    z_corners = [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2]
 
     # rotate and translate 3d bounding box
-    corners_3d = np.dot(R, np.vstack([x_corners,y_corners,z_corners]))
-    #print corners_3d.shape
-    corners_3d[0,:] = corners_3d[0,:] + obj.t[0];
-    corners_3d[1,:] = corners_3d[1,:] + obj.t[1];
-    corners_3d[2,:] = corners_3d[2,:] + obj.t[2];
-    #print 'cornsers_3d: ', corners_3d
+    corners_3d = np.dot(R, np.vstack([x_corners, y_corners, z_corners]))
+    # print corners_3d.shape
+    corners_3d[0, :] = corners_3d[0, :] + obj.t[0]
+    corners_3d[1, :] = corners_3d[1, :] + obj.t[1]
+    corners_3d[2, :] = corners_3d[2, :] + obj.t[2]
+    # print 'cornsers_3d: ', corners_3d
     # only draw 3d bounding box for objs in front of the camera
-    if np.any(corners_3d[2,:]<0.1):
+    if np.any(corners_3d[2, :] < 0.1):
         corners_2d = None
         return corners_2d, np.transpose(corners_3d)
 
     # project the 3d bounding box into the image plane
-    corners_2d = project_to_image(np.transpose(corners_3d), P);
-    #print 'corners_2d: ', corners_2d
+    corners_2d = project_to_image(np.transpose(corners_3d), P)
+    # print 'corners_2d: ', corners_2d
     return corners_2d, np.transpose(corners_3d)
 
 
 def compute_orientation_3d(obj, P):
-    ''' Takes an object and a projection matrix (P) and projects the 3d
+    """ Takes an object and a projection matrix (P) and projects the 3d
         object orientation vector into the image plane.
         Returns:
             orientation_2d: (2,2) array in left image coord.
             orientation_3d: (2,3) array in in rect camera coord.
-    '''
+    """
 
     # compute rotational matrix around yaw axis
     R = roty(obj.ry)
 
     # orientation in object coordinate system
-    orientation_3d = np.array([[0.0, obj.l],[0,0],[0,0]])
+    orientation_3d = np.array([[0.0, obj.l], [0, 0], [0, 0]])
 
     # rotate and translate in camera coordinate system, project in image
     orientation_3d = np.dot(R, orientation_3d)
-    orientation_3d[0,:] = orientation_3d[0,:] + obj.t[0]
-    orientation_3d[1,:] = orientation_3d[1,:] + obj.t[1]
-    orientation_3d[2,:] = orientation_3d[2,:] + obj.t[2]
+    orientation_3d[0, :] = orientation_3d[0, :] + obj.t[0]
+    orientation_3d[1, :] = orientation_3d[1, :] + obj.t[1]
+    orientation_3d[2, :] = orientation_3d[2, :] + obj.t[2]
 
     # vector behind image plane?
-    if np.any(orientation_3d[2,:]<0.1):
-      orientation_2d = None
-      return orientation_2d, np.transpose(orientation_3d)
+    if np.any(orientation_3d[2, :] < 0.1):
+        orientation_2d = None
+        return orientation_2d, np.transpose(orientation_3d)
 
     # project orientation into the image plane
-    orientation_2d = project_to_image(np.transpose(orientation_3d), P);
+    orientation_2d = project_to_image(np.transpose(orientation_3d), P)
     return orientation_2d, np.transpose(orientation_3d)
 
-def draw_projected_box3d(image, qs, color=(0,255,0), thickness=2):
-    ''' Draw 3d bounding box in image
+
+def draw_projected_box3d(image, qs, color=(0, 255, 0), thickness=2):
+    """ Draw 3d bounding box in image
         qs: (8,3) array of vertices for the 3d box in following order:
             1 -------- 0
            /|         /|
@@ -648,108 +679,120 @@ def draw_projected_box3d(image, qs, color=(0,255,0), thickness=2):
           . 5 -------- 4
           |/         |/
           6 -------- 7
-    '''
+    """
     qs = qs.astype(np.int32)
-    for k in range(0,4):
-       # Ref: http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
-       i,j=k,(k+1)%4
-       # use LINE_AA for opencv3
-       #cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness, cv2.CV_AA)
-       cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness)
-       i,j=k+4,(k+1)%4 + 4
-       cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness)
-
-       i,j=k,k+4
-       cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness)
+    for k in range(0, 4):
+        # Ref: http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
+        i, j = k, (k + 1) % 4
+        # use LINE_AA for opencv3
+        # cv2.line(image, (qs[i,0],qs[i,1]), (qs[j,0],qs[j,1]), color, thickness, cv2.CV_AA)
+        cv2.line(image, (qs[i, 0], qs[i, 1]), (qs[j, 0], qs[j, 1]), color, thickness)
+        i, j = k + 4, (k + 1) % 4 + 4
+        cv2.line(image, (qs[i, 0], qs[i, 1]), (qs[j, 0], qs[j, 1]), color, thickness)
+
+        i, j = k, k + 4
+        cv2.line(image, (qs[i, 0], qs[i, 1]), (qs[j, 0], qs[j, 1]), color, thickness)
     return image
 
+
 def draw_top_image(lidar_top):
-    top_image = np.sum(lidar_top,axis=2)
-    top_image = top_image-np.min(top_image)
-    divisor = np.max(top_image)-np.min(top_image)
-    top_image = (top_image/divisor*255)
+    top_image = np.sum(lidar_top, axis=2)
+    top_image = top_image - np.min(top_image)
+    divisor = np.max(top_image) - np.min(top_image)
+    top_image = top_image / divisor * 255
     top_image = np.dstack((top_image, top_image, top_image)).astype(np.uint8)
     return top_image
 
-def draw_box3d_on_top(image, boxes3d, color=(255,255,255), thickness=1,scores=None, text_lables=[], is_gt=False):
 
-    #if scores is not None and scores.shape[0] >0:
-        #print(scores.shape)
-        #scores=scores[:,0]
+def draw_box3d_on_top(
+    image,
+    boxes3d,
+    color=(255, 255, 255),
+    thickness=1,
+    scores=None,
+    text_lables=[],
+    is_gt=False,
+):
+
+    # if scores is not None and scores.shape[0] >0:
+    # print(scores.shape)
+    # scores=scores[:,0]
     font = cv2.FONT_HERSHEY_SIMPLEX
     img = image.copy()
-    num =len(boxes3d)
-    startx =5
+    num = len(boxes3d)
+    startx = 5
     for n in range(num):
-        b   = boxes3d[n]
-        x0 = b[0,0]
-        y0 = b[0,1]
-        x1 = b[1,0]
-        y1 = b[1,1]
-        x2 = b[2,0]
-        y2 = b[2,1]
-        x3 = b[3,0]
-        y3 = b[3,1]
-        u0,v0=lidar_to_top_coords(x0,y0)
-        u1,v1=lidar_to_top_coords(x1,y1)
-        u2,v2=lidar_to_top_coords(x2,y2)
-        u3,v3=lidar_to_top_coords(x3,y3)
+        b = boxes3d[n]
+        x0 = b[0, 0]
+        y0 = b[0, 1]
+        x1 = b[1, 0]
+        y1 = b[1, 1]
+        x2 = b[2, 0]
+        y2 = b[2, 1]
+        x3 = b[3, 0]
+        y3 = b[3, 1]
+        u0, v0 = lidar_to_top_coords(x0, y0)
+        u1, v1 = lidar_to_top_coords(x1, y1)
+        u2, v2 = lidar_to_top_coords(x2, y2)
+        u3, v3 = lidar_to_top_coords(x3, y3)
         if is_gt:
             color = (0, 255, 0)
             startx = 5
         else:
-            color=heat_map_rgb(0.,1., scores[n]) if scores is not None else 255
+            color = heat_map_rgb(0.0, 1.0, scores[n]) if scores is not None else 255
             startx = 85
-        cv2.line(img, (u0,v0), (u1,v1), color, thickness, cv2.LINE_AA)
-        cv2.line(img, (u1,v1), (u2,v2), color, thickness, cv2.LINE_AA)
-        cv2.line(img, (u2,v2), (u3,v3), color, thickness, cv2.LINE_AA)
-        cv2.line(img, (u3,v3), (u0,v0), color, thickness, cv2.LINE_AA)
+        cv2.line(img, (u0, v0), (u1, v1), color, thickness, cv2.LINE_AA)
+        cv2.line(img, (u1, v1), (u2, v2), color, thickness, cv2.LINE_AA)
+        cv2.line(img, (u2, v2), (u3, v3), color, thickness, cv2.LINE_AA)
+        cv2.line(img, (u3, v3), (u0, v0), color, thickness, cv2.LINE_AA)
     for n in range(len(text_lables)):
-        text_pos = (startx, 25*(n+1))
+        text_pos = (startx, 25 * (n + 1))
         cv2.putText(img, text_lables[n], text_pos, font, 0.5, color, 0, cv2.LINE_AA)
-    return  img
-
+    return img
 
 
-
-#hypothesis function
+# hypothesis function
 def hypothesis_func(w, x):
-    w1,w0 = w
-    return w1*x + w0
+    w1, w0 = w
+    return w1 * x + w0
+
 
-#error function
+# error function
 def error_func(w, train_x, train_y):
     return hypothesis_func(w, train_x) - train_y
 
+
 def dump_fit_func(w_fit):
-    w1,w0=w_fit
-    print("fitting line=",str(w1)+"*x + "+str(w0))
+    w1, w0 = w_fit
+    print("fitting line=", str(w1) + "*x + " + str(w0))
     return
 
-#square error
+
+# square error
 def dump_fit_cost(w_fit, train_x, train_y):
     error = error_func(w_fit, train_x, train_y)
-    square_error = sum(e*e for e in error)
-    print('fitting cost:',str(square_error))
+    square_error = sum(e * e for e in error)
+    print("fitting cost:", str(square_error))
     return square_error
 
+
 def linear_regression(train_x, train_y, test_x):
-    #train set
-    #train_x = np.array([8.19,2.72,6.39,8.71,4.7,2.66,3.78])
-    #train_y = np.array([7.01,2.78,6.47,6.71,4.1,4.23,4.05])
+    # train set
+    # train_x = np.array([8.19,2.72,6.39,8.71,4.7,2.66,3.78])
+    # train_y = np.array([7.01,2.78,6.47,6.71,4.1,4.23,4.05])
 
-    #linear regression by leastsq
-    #msg = "invoke scipy leastsq"
-    w_init = [20, 1]#weight factor init
+    # linear regression by leastsq
+    # msg = "invoke scipy leastsq"
+    w_init = [20, 1]  # weight factor init
     fit_ret = leastsq(error_func, w_init, args=(train_x, train_y))
     w_fit = fit_ret[0]
 
-    #dump fit result
+    # dump fit result
     dump_fit_func(w_fit)
     fit_cost = dump_fit_cost(w_fit, train_x, train_y)
 
-    #test set
-    #test_x = np.array(np.arange(train_x.min(), train_x.max(), 1.0))
+    # test set
+    # test_x = np.array(np.arange(train_x.min(), train_x.max(), 1.0))
     test_y = hypothesis_func(w_fit, test_x)
     test_y0 = hypothesis_func(w_fit, train_x)
     return test_y, test_y0
diff --git a/viz_util.py b/viz_util.py
index f5b6958..1625262 100644
--- a/viz_util.py
+++ b/viz_util.py
@@ -1,19 +1,20 @@
-''' Visualization code for point clouds and 3D bounding boxes with mayavi.
+""" Visualization code for point clouds and 3D bounding boxes with mayavi.
 
 Modified by Charles R. Qi
 Date: September 2017
 
 Ref: https://github.com/hengck23/didi-udacity-2017/blob/master/baseline-04/kitti_data/draw.py
-'''
+"""
 
 import numpy as np
 import mayavi.mlab as mlab
 
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
 
+
 def normalize(vec):
     """normalizes an Nd list of vectors or a single vector
     to unit length.
@@ -33,12 +34,13 @@ def normalize(vec):
     # calculate the length
     # this is a duplicate of length(vec) because we
     # always want an array, even a 0-d array.
-    return (vec.T  / np.sqrt(np.sum(vec**2,axis=-1))).T
+    return (vec.T / np.sqrt(np.sum(vec ** 2, axis=-1))).T
+
 
 def rotation_matrix_numpy0(axis, theta, dtype=None):
-    #dtype = dtype or axis.dtype
+    # dtype = dtype or axis.dtype
     # make sure the vector is normalized
-    if not np.isclose(np.linalg.norm(axis), 1.):
+    if not np.isclose(np.linalg.norm(axis), 1.0):
         axis = normalize(axis)
 
     thetaOver2 = theta * 0.5
@@ -49,140 +51,281 @@ def rotation_matrix_numpy0(axis, theta, dtype=None):
             sinThetaOver2 * axis[0],
             sinThetaOver2 * axis[1],
             sinThetaOver2 * axis[2],
-            np.cos(thetaOver2)
+            np.cos(thetaOver2),
         ]
     )
 
 
 def rotation_matrix_numpy(axis, theta):
-    mat = np.eye(3,3)
-    axis = axis/np.sqrt(np.dot(axis, axis))
-    a = np.cos(theta/2.)
-    b, c, d = -axis*np.sin(theta/2.)
+    mat = np.eye(3, 3)
+    axis = axis / np.sqrt(np.dot(axis, axis))
+    a = np.cos(theta / 2.0)
+    b, c, d = -axis * np.sin(theta / 2.0)
+
+    return np.array(
+        [
+            [a * a + b * b - c * c - d * d, 2 * (b * c - a * d), 2 * (b * d + a * c)],
+            [2 * (b * c + a * d), a * a + c * c - b * b - d * d, 2 * (c * d - a * b)],
+            [2 * (b * d - a * c), 2 * (c * d + a * b), a * a + d * d - b * b - c * c],
+        ]
+    )
 
-    return np.array([[a*a+b*b-c*c-d*d, 2*(b*c-a*d), 2*(b*d+a*c)],
-                  [2*(b*c+a*d), a*a+c*c-b*b-d*d, 2*(c*d-a*b)],
-                  [2*(b*d-a*c), 2*(c*d+a*b), a*a+d*d-b*b-c*c]])
 
 def rotx(t):
-    ''' 3D Rotation about the x-axis. '''
+    """ 3D Rotation about the x-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[1,  0,  0],
-                     [0,  c, -s],
-                     [0,  s,  c]])
+    return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])
 
 
 def roty(t):
-    ''' Rotation about the y-axis. '''
+    """ Rotation about the y-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[c,  0,  s],
-                     [0,  1,  0],
-                     [-s, 0,  c]])
+    return np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]])
 
 
 def rotz(t):
-    ''' Rotation about the z-axis. '''
+    """ Rotation about the z-axis. """
     c = np.cos(t)
     s = np.sin(t)
-    return np.array([[c, -s,  0],
-                     [s,  c,  0],
-                     [0,  0,  1]])
+    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])
+
 
 def draw_lidar_simple(pc, color=None):
-    ''' Draw lidar points. simplest set up. '''
-    fig = mlab.figure(figure=None, bgcolor=(0,0,0), fgcolor=None, engine=None, size=(1600, 1000))
-    if color is None: color = pc[:,2]
-    #draw points
-    mlab.points3d(pc[:,0], pc[:,1], pc[:,2], color, color=None, mode='point', colormap = 'gnuplot', scale_factor=1, figure=fig)
-    #draw origin
-    mlab.points3d(0, 0, 0, color=(1,1,1), mode='sphere', scale_factor=0.2)
-    #draw axis
-    axes=np.array([
-        [2.,0.,0.,0.],
-        [0.,2.,0.,0.],
-        [0.,0.,2.,0.],
-    ],dtype=np.float64)
-    mlab.plot3d([0, axes[0,0]], [0, axes[0,1]], [0, axes[0,2]], color=(1,0,0), tube_radius=None, figure=fig)
-    mlab.plot3d([0, axes[1,0]], [0, axes[1,1]], [0, axes[1,2]], color=(0,1,0), tube_radius=None, figure=fig)
-    mlab.plot3d([0, axes[2,0]], [0, axes[2,1]], [0, axes[2,2]], color=(0,0,1), tube_radius=None, figure=fig)
-    mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
-    return fig
-#pts_mode='sphere'
-def draw_lidar(pc,
+    """ Draw lidar points. simplest set up. """
+    fig = mlab.figure(
+        figure=None, bgcolor=(0, 0, 0), fgcolor=None, engine=None, size=(1600, 1000)
+    )
+    if color is None:
+        color = pc[:, 2]
+    # draw points
+    mlab.points3d(
+        pc[:, 0],
+        pc[:, 1],
+        pc[:, 2],
+        color,
         color=None,
-        fig=None,
-        bgcolor=(0,0,0),
-        pts_scale=0.3,
-        pts_mode='sphere',
-        pts_color=None,
-        color_by_intensity=False,
-        pc_label=False):
-    ''' Draw lidar points
+        mode="point",
+        colormap="gnuplot",
+        scale_factor=1,
+        figure=fig,
+    )
+    # draw origin
+    mlab.points3d(0, 0, 0, color=(1, 1, 1), mode="sphere", scale_factor=0.2)
+    # draw axis
+    axes = np.array(
+        [[2.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 0.0, 2.0, 0.0]],
+        dtype=np.float64,
+    )
+    mlab.plot3d(
+        [0, axes[0, 0]],
+        [0, axes[0, 1]],
+        [0, axes[0, 2]],
+        color=(1, 0, 0),
+        tube_radius=None,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [0, axes[1, 0]],
+        [0, axes[1, 1]],
+        [0, axes[1, 2]],
+        color=(0, 1, 0),
+        tube_radius=None,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [0, axes[2, 0]],
+        [0, axes[2, 1]],
+        [0, axes[2, 2]],
+        color=(0, 0, 1),
+        tube_radius=None,
+        figure=fig,
+    )
+    mlab.view(
+        azimuth=180,
+        elevation=70,
+        focalpoint=[12.0909996, -1.04700089, -2.03249991],
+        distance=62.0,
+        figure=fig,
+    )
+    return fig
+
+
+# pts_mode='sphere'
+def draw_lidar(
+    pc,
+    color=None,
+    fig=None,
+    bgcolor=(0, 0, 0),
+    pts_scale=0.3,
+    pts_mode="sphere",
+    pts_color=None,
+    color_by_intensity=False,
+    pc_label=False,
+):
+    """ Draw lidar points
     Args:
         pc: numpy array (n,3) of XYZ
         color: numpy array (n) of intensity or whatever
         fig: mayavi figure handler, if None create new one otherwise will use it
     Returns:
         fig: created or used fig
-    '''
-    #ind = (pc[:,2]< -1.65)
-    #pc = pc[ind]
-    pts_mode='point'
-    print("====================",pc.shape)
-    if fig is None: fig = mlab.figure(figure=None, bgcolor=bgcolor, fgcolor=None, engine=None, size=(1600, 1000))
-    if color is None: color = pc[:,2]
-    if pc_label: color = pc[:,4]
-    if color_by_intensity: color = pc[:,2]
-
-    mlab.points3d(pc[:,0], pc[:,1], pc[:,2], color, color=pts_color, mode=pts_mode, colormap = 'gnuplot', scale_factor=pts_scale, figure=fig)
-
-    #draw origin
-    mlab.points3d(0, 0, 0, color=(1,1,1), mode='sphere', scale_factor=0.2)
-
-    #draw axis
-    axes=np.array([
-        [2.,0.,0.,0.],
-        [0.,2.,0.,0.],
-        [0.,0.,2.,0.],
-    ],dtype=np.float64)
-    mlab.plot3d([0, axes[0,0]], [0, axes[0,1]], [0, axes[0,2]], color=(1,0,0), tube_radius=None, figure=fig)
-    mlab.plot3d([0, axes[1,0]], [0, axes[1,1]], [0, axes[1,2]], color=(0,1,0), tube_radius=None, figure=fig)
-    mlab.plot3d([0, axes[2,0]], [0, axes[2,1]], [0, axes[2,2]], color=(0,0,1), tube_radius=None, figure=fig)
+    """
+    # ind = (pc[:,2]< -1.65)
+    # pc = pc[ind]
+    pts_mode = "point"
+    print("====================", pc.shape)
+    if fig is None:
+        fig = mlab.figure(
+            figure=None, bgcolor=bgcolor, fgcolor=None, engine=None, size=(1600, 1000)
+        )
+    if color is None:
+        color = pc[:, 2]
+    if pc_label:
+        color = pc[:, 4]
+    if color_by_intensity:
+        color = pc[:, 2]
+
+    mlab.points3d(
+        pc[:, 0],
+        pc[:, 1],
+        pc[:, 2],
+        color,
+        color=pts_color,
+        mode=pts_mode,
+        colormap="gnuplot",
+        scale_factor=pts_scale,
+        figure=fig,
+    )
+
+    # draw origin
+    mlab.points3d(0, 0, 0, color=(1, 1, 1), mode="sphere", scale_factor=0.2)
+
+    # draw axis
+    axes = np.array(
+        [[2.0, 0.0, 0.0, 0.0], [0.0, 2.0, 0.0, 0.0], [0.0, 0.0, 2.0, 0.0]],
+        dtype=np.float64,
+    )
+    mlab.plot3d(
+        [0, axes[0, 0]],
+        [0, axes[0, 1]],
+        [0, axes[0, 2]],
+        color=(1, 0, 0),
+        tube_radius=None,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [0, axes[1, 0]],
+        [0, axes[1, 1]],
+        [0, axes[1, 2]],
+        color=(0, 1, 0),
+        tube_radius=None,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [0, axes[2, 0]],
+        [0, axes[2, 1]],
+        [0, axes[2, 2]],
+        color=(0, 0, 1),
+        tube_radius=None,
+        figure=fig,
+    )
 
     # draw fov (todo: update to real sensor spec.)
-    fov=np.array([  # 45 degree
-        [20., 20., 0.,0.],
-        [20.,-20., 0.,0.],
-    ],dtype=np.float64)
+    fov = np.array(
+        [[20.0, 20.0, 0.0, 0.0], [20.0, -20.0, 0.0, 0.0]], dtype=np.float64  # 45 degree
+    )
 
-    mlab.plot3d([0, fov[0,0]], [0, fov[0,1]], [0, fov[0,2]], color=(1,1,1), tube_radius=None, line_width=1, figure=fig)
-    mlab.plot3d([0, fov[1,0]], [0, fov[1,1]], [0, fov[1,2]], color=(1,1,1), tube_radius=None, line_width=1, figure=fig)
+    mlab.plot3d(
+        [0, fov[0, 0]],
+        [0, fov[0, 1]],
+        [0, fov[0, 2]],
+        color=(1, 1, 1),
+        tube_radius=None,
+        line_width=1,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [0, fov[1, 0]],
+        [0, fov[1, 1]],
+        [0, fov[1, 2]],
+        color=(1, 1, 1),
+        tube_radius=None,
+        line_width=1,
+        figure=fig,
+    )
 
     # draw square region
-    TOP_Y_MIN=-20
-    TOP_Y_MAX=20
-    TOP_X_MIN=0
-    TOP_X_MAX=40
-    TOP_Z_MIN=-2.0
-    TOP_Z_MAX=0.4
+    TOP_Y_MIN = -20
+    TOP_Y_MAX = 20
+    TOP_X_MIN = 0
+    TOP_X_MAX = 40
+    TOP_Z_MIN = -2.0
+    TOP_Z_MAX = 0.4
 
     x1 = TOP_X_MIN
     x2 = TOP_X_MAX
     y1 = TOP_Y_MIN
     y2 = TOP_Y_MAX
-    mlab.plot3d([x1, x1], [y1, y2], [0,0], color=(0.5,0.5,0.5), tube_radius=0.1, line_width=1, figure=fig)
-    mlab.plot3d([x2, x2], [y1, y2], [0,0], color=(0.5,0.5,0.5), tube_radius=0.1, line_width=1, figure=fig)
-    mlab.plot3d([x1, x2], [y1, y1], [0,0], color=(0.5,0.5,0.5), tube_radius=0.1, line_width=1, figure=fig)
-    mlab.plot3d([x1, x2], [y2, y2], [0,0], color=(0.5,0.5,0.5), tube_radius=0.1, line_width=1, figure=fig)
+    mlab.plot3d(
+        [x1, x1],
+        [y1, y2],
+        [0, 0],
+        color=(0.5, 0.5, 0.5),
+        tube_radius=0.1,
+        line_width=1,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [x2, x2],
+        [y1, y2],
+        [0, 0],
+        color=(0.5, 0.5, 0.5),
+        tube_radius=0.1,
+        line_width=1,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [x1, x2],
+        [y1, y1],
+        [0, 0],
+        color=(0.5, 0.5, 0.5),
+        tube_radius=0.1,
+        line_width=1,
+        figure=fig,
+    )
+    mlab.plot3d(
+        [x1, x2],
+        [y2, y2],
+        [0, 0],
+        color=(0.5, 0.5, 0.5),
+        tube_radius=0.1,
+        line_width=1,
+        figure=fig,
+    )
 
-    #mlab.orientation_axes()
-    mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
+    # mlab.orientation_axes()
+    mlab.view(
+        azimuth=180,
+        elevation=70,
+        focalpoint=[12.0909996, -1.04700089, -2.03249991],
+        distance=62.0,
+        figure=fig,
+    )
     return fig
 
-def draw_gt_boxes3d(gt_boxes3d, fig, color=(1,1,1), line_width=1, draw_text=True, text_scale=(1,1,1), color_list=None):
-    ''' Draw 3D bounding boxes
+
+def draw_gt_boxes3d(
+    gt_boxes3d,
+    fig,
+    color=(1, 1, 1),
+    line_width=1,
+    draw_text=True,
+    text_scale=(1, 1, 1),
+    color_list=None,
+):
+    """ Draw 3D bounding boxes
     Args:
         gt_boxes3d: numpy array (n,8,3) for XYZs of the box corners
         fig: mayavi figure handler
@@ -193,29 +336,63 @@ def draw_gt_boxes3d(gt_boxes3d, fig, color=(1,1,1), line_width=1, draw_text=True
         color_list: a list of RGB tuple, if not None, overwrite color.
     Returns:
         fig: updated fig
-    '''
+    """
     num = len(gt_boxes3d)
     for n in range(num):
         b = gt_boxes3d[n]
         if color_list is not None:
             color = color_list[n]
-        if draw_text: mlab.text3d(b[4,0], b[4,1], b[4,2], '%d'%n, scale=text_scale, color=color, figure=fig)
-        for k in range(0,4):
-            #http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
-            i,j=k,(k+1)%4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-
-            i,j=k+4,(k+1)%4 + 4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-
-            i,j=k,k+4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-    #mlab.show(1)
-    #mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
+        if draw_text:
+            mlab.text3d(
+                b[4, 0],
+                b[4, 1],
+                b[4, 2],
+                "%d" % n,
+                scale=text_scale,
+                color=color,
+                figure=fig,
+            )
+        for k in range(0, 4):
+            # http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
+            i, j = k, (k + 1) % 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+
+            i, j = k + 4, (k + 1) % 4 + 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+
+            i, j = k, k + 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+    # mlab.show(1)
+    # mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
     return fig
 
+
 def xyzwhl2eight(xyzwhl):
-    ''' Draw 3d bounding box in image
+    """ Draw 3d bounding box in image
         qs: (8,3) array of vertices for the 3d box in following order:
             7 -------- 6
            /|         /|
@@ -224,17 +401,56 @@ def xyzwhl2eight(xyzwhl):
           . 3 -------- 2
           |/         |/
           0 -------- 1
-    '''
-    x,y,z,w,h,l = xyzwhl[:6]
-    box8 = np.array([
-        [x+w/2, x+w/2, x-w/2, x-w/2, x+w/2, x+w/2, x-w/2, x-w/2 ],
-        [y-h/2, y+h/2, y+h/2, y-h/2, y-h/2, y+h/2, y+h/2, y-h/2 ],
-        [z-l/2, z-l/2, z-l/2, z-l/2, z+l/2, z+l/2, z+l/2, z+l/2 ]
-        ])
+    """
+    x, y, z, w, h, l = xyzwhl[:6]
+    box8 = np.array(
+        [
+            [
+                x + w / 2,
+                x + w / 2,
+                x - w / 2,
+                x - w / 2,
+                x + w / 2,
+                x + w / 2,
+                x - w / 2,
+                x - w / 2,
+            ],
+            [
+                y - h / 2,
+                y + h / 2,
+                y + h / 2,
+                y - h / 2,
+                y - h / 2,
+                y + h / 2,
+                y + h / 2,
+                y - h / 2,
+            ],
+            [
+                z - l / 2,
+                z - l / 2,
+                z - l / 2,
+                z - l / 2,
+                z + l / 2,
+                z + l / 2,
+                z + l / 2,
+                z + l / 2,
+            ],
+        ]
+    )
     return box8.T
 
-def draw_xyzwhl(gt_boxes3d, fig, color=(1,1,1), line_width=1, draw_text=True, text_scale=(1,1,1), color_list=None, rot=False):
-    ''' Draw 3D bounding boxes
+
+def draw_xyzwhl(
+    gt_boxes3d,
+    fig,
+    color=(1, 1, 1),
+    line_width=1,
+    draw_text=True,
+    text_scale=(1, 1, 1),
+    color_list=None,
+    rot=False,
+):
+    """ Draw 3D bounding boxes
     Args:
         gt_boxes3d: numpy array (n,8,3) for XYZs of the box corners
         fig: mayavi figure handler
@@ -245,7 +461,7 @@ def draw_xyzwhl(gt_boxes3d, fig, color=(1,1,1), line_width=1, draw_text=True, te
         color_list: a list of RGB tuple, if not None, overwrite color.
     Returns:
         fig: updated fig
-    '''
+    """
     num = len(gt_boxes3d)
     for n in range(num):
         print(gt_boxes3d[n])
@@ -253,35 +469,58 @@ def draw_xyzwhl(gt_boxes3d, fig, color=(1,1,1), line_width=1, draw_text=True, te
         b = xyzwhl2eight(box6)
         if rot:
             b = b.dot(rotz(box6[7]))
-            #b = b.dot(rotx(box6[6]))
-            #print(rotz(box6[6]))
-            #b = b.dot( rotz(box6[6]).dot(rotz(box6[7])) )
-            vec = np.array([-1,1,0])
+            # b = b.dot(rotx(box6[6]))
+            # print(rotz(box6[6]))
+            # b = b.dot( rotz(box6[6]).dot(rotz(box6[7])) )
+            vec = np.array([-1, 1, 0])
             b = b.dot(rotation_matrix_numpy(vec, box6[6]))
-            #b = b.dot(roty(box6[7]))
-
+            # b = b.dot(roty(box6[7]))
 
-        print(b.shape,b)
+        print(b.shape, b)
         if color_list is not None:
             color = color_list[n]
-        #if draw_text: mlab.text3d(b[4,0], b[4,1], b[4,2], '%d'%n, scale=text_scale, color=color, figure=fig)
-        for k in range(0,4):
-            #http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
-            i,j=k,(k+1)%4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-
-            i,j=k+4,(k+1)%4 + 4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-
-            i,j=k,k+4
-            mlab.plot3d([b[i,0], b[j,0]], [b[i,1], b[j,1]], [b[i,2], b[j,2]], color=color, tube_radius=None, line_width=line_width, figure=fig)
-    #mlab.show(1)
-    #mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
+        # if draw_text: mlab.text3d(b[4,0], b[4,1], b[4,2], '%d'%n, scale=text_scale, color=color, figure=fig)
+        for k in range(0, 4):
+            # http://docs.enthought.com/mayavi/mayavi/auto/mlab_helper_functions.html
+            i, j = k, (k + 1) % 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+
+            i, j = k + 4, (k + 1) % 4 + 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+
+            i, j = k, k + 4
+            mlab.plot3d(
+                [b[i, 0], b[j, 0]],
+                [b[i, 1], b[j, 1]],
+                [b[i, 2], b[j, 2]],
+                color=color,
+                tube_radius=None,
+                line_width=line_width,
+                figure=fig,
+            )
+    # mlab.show(1)
+    # mlab.view(azimuth=180, elevation=70, focalpoint=[ 12.0909996 , -1.04700089, -2.03249991], distance=62.0, figure=fig)
     return fig
 
 
-if __name__=='__main__':
-    pc = np.loadtxt('mayavi/kitti_sample_scan.txt')
+if __name__ == "__main__":
+    pc = np.loadtxt("mayavi/kitti_sample_scan.txt")
     fig = draw_lidar(pc)
-    mlab.savefig('pc_view.jpg', figure=fig)
+    mlab.savefig("pc_view.jpg", figure=fig)
     raw_input()