proj file

+import numpy as np
+import math
+import os
+import argparse
+import cv2
+import time
+import torch
+import tensorflow as tf
+
+import utils.utils as utils
+from models import *
+import torch.utils.data as torch_data
+
+import utils.kitti_utils as kitti_utils
+import utils.kitti_aug_utils as aug_utils
+import utils.kitti_bev_utils as bev_utils
+from utils.kitti_yolo_dataset import KittiYOLODataset
+import utils.config as cnf
+#import utils.mayavi_viewer as mview
+from socket import *
+import struct
+
+def predictions_to_kitti_format(img_detections, calib, img_shape_2d, img_size, RGB_Map=None):
+    predictions = np.zeros([50, 7], dtype=np.float32)
+    count = 0
+    for detections in img_detections:
+        if detections is None:
+            continue
+        # Rescale boxes to original image
+        for x, y, w, l, im, re, conf, cls_conf, cls_pred in detections:
+            yaw = np.arctan2(im, re)
+            predictions[count, :] = cls_pred, x/img_size, y/img_size, w/img_size, l/img_size, im, re
+            count += 1
+
+    predictions = bev_utils.inverse_yolo_target(predictions, cnf.boundary)
+    if predictions.shape[0]:
+        predictions[:, 1:] = aug_utils.lidar_to_camera_box(predictions[:, 1:], calib.V2C, calib.R0, calib.P)
+
+    objects_new = []
+    corners3d = []
+    for index, l in enumerate(predictions):
+
+        str = "Pedestrian"
+        if l[0] == 0:str="Car"
+        elif l[0] == 1:str="Pedestrian"
+        elif l[0] == 2: str="Cyclist"
+        else:str = "DontCare"
+        line = '%s -1 -1 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0' % str
+
+        obj = kitti_utils.Object3d(line)
+        obj.t = l[1:4]
+        obj.h,obj.w,obj.l = l[4:7]
+        obj.ry = np.arctan2(math.sin(l[7]), math.cos(l[7]))
+    
+        _, corners_3d = kitti_utils.compute_box_3d(obj, calib.P)
+        corners3d.append(corners_3d)
+        objects_new.append(obj)
+
+    if len(corners3d) > 0:
+        corners3d = np.array(corners3d)
+        img_boxes, _ = calib.corners3d_to_img_boxes(corners3d)
+
+        img_boxes[:, 0] = np.clip(img_boxes[:, 0], 0, img_shape_2d[1] - 1)
+        img_boxes[:, 1] = np.clip(img_boxes[:, 1], 0, img_shape_2d[0] - 1)
+        img_boxes[:, 2] = np.clip(img_boxes[:, 2], 0, img_shape_2d[1] - 1)
+        img_boxes[:, 3] = np.clip(img_boxes[:, 3], 0, img_shape_2d[0] - 1)
+
+        img_boxes_w = img_boxes[:, 2] - img_boxes[:, 0]
+        img_boxes_h = img_boxes[:, 3] - img_boxes[:, 1]
+        box_valid_mask = np.logical_and(img_boxes_w < img_shape_2d[1] * 0.8, img_boxes_h < img_shape_2d[0] * 0.8)
+
+    for i, obj in enumerate(objects_new):
+        x, z, ry = obj.t[0], obj.t[2], obj.ry
+        beta = np.arctan2(z, x)
+        alpha = -np.sign(beta) * np.pi / 2 + beta + ry
+
+        obj.alpha = alpha
+        obj.box2d = img_boxes[i, :]
+
+    if RGB_Map is not None:
+        labels, noObjectLabels = kitti_utils.read_labels_for_bevbox(objects_new)    
+        if not noObjectLabels:
+            labels[:, 1:] = aug_utils.camera_to_lidar_box(labels[:, 1:], calib.V2C, calib.R0, calib.P) # convert rect cam to velo cord
+
+        target = bev_utils.build_yolo_target(labels)
+        utils.draw_box_in_bev(RGB_Map, target)
+
+    return objects_new
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_def", type=str, default="config/complex_tiny_yolov3.cfg", help="path to model definition file")
+    parser.add_argument("--weights_path", type=str, default="checkpoints/tiny-yolov3_ckpt_epoch-220.pth", help="path to weights file")
+    parser.add_argument("--class_path", type=str, default="data/classes.names", help="path to class label file")
+    parser.add_argument("--conf_thres", type=float, default=0.01, help="object confidence threshold")
+    parser.add_argument("--nms_thres", type=float, default=0.01, help="iou thresshold for non-maximum suppression")
+    parser.add_argument("--img_size", type=int, default=cnf.BEV_WIDTH, help="size of each image dimension")
+    parser.add_argument("--split", type=str, default="valid", help="text file having image lists in dataset")
+    parser.add_argument("--folder", type=str, default="training", help="directory name that you downloaded all dataset")
+    opt = parser.parse_args()
+    print(opt)
+
+    classes = utils.load_classes(opt.class_path)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Set up model
+    model = Darknet(opt.model_def, img_size=opt.img_size).to(device)
+    # Load checkpoint weights
+    model.load_state_dict(torch.load(opt.weights_path,map_location='cpu'))
+    # Eval mode
+    model.eval()
+    
+    dataset = KittiYOLODataset(cnf.root_dir, split=opt.split, mode='TEST', folder=opt.folder, data_aug=False)
+    data_loader = torch_data.DataLoader(dataset, 1, shuffle=False)
+
+    Tensor = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor
+
+    start_time = time.time()
+    detections_list = []
+    #socket
+    boardSock = socket(AF_INET, SOCK_DGRAM)
+    board_add = ('192.168.2.99',12400)
+    frame = 0
+    for index, (img_paths, bev_maps) in enumerate(data_loader):
+
+        # Configure bev image
+        input_imgs = Variable(bev_maps.type(Tensor))
+        #input_imgs = input_imgs * 0.4
+
+        # Get detections
+        with torch.no_grad():
+            detections = model(input_imgs)
+            detections = utils.non_max_suppression_rotated_bbox(detections, opt.conf_thres, opt.nms_thres)
+
+        end_time = time.time()
+        print(f"FPS: {(1.0/(end_time-start_time)):0.2f}")
+        start_time = end_time
+
+        img_detections = []  # Stores detections for each image index
+        img_detections.extend(detections)
+
+        bev_maps = torch.squeeze(bev_maps).numpy()
+
+        RGB_Map = np.zeros((cnf.BEV_WIDTH, cnf.BEV_WIDTH, 3))
+        RGB_Map[:, :, 2] = bev_maps[0, :, :]  # r_map
+        RGB_Map[:, :, 1] = bev_maps[1, :, :]  # g_map
+        RGB_Map[:, :, 0] = bev_maps[2, :, :]  # b_map
+
+        RGB_Map *= 255
+        RGB_Map = RGB_Map.astype(np.uint8)
+        del detections_list[:]
+        count = 0
+        for detections in img_detections:
+            if detections is None:
+                continue
+
+            # Rescale boxes to original image
+            detections = utils.rescale_boxes(detections, opt.img_size, RGB_Map.shape[:2])
+	    # send detection count
+            boardSock.sendto(str(len(detections)).encode(), board_add)
+            for x, y, w, l, im, re, conf, cls_conf, cls_pred in detections:
+                yaw = np.arctan2(im, re)
+                # Draw rotated box
+                bev_utils.drawRotatedBox(RGB_Map, x, y, w, l, yaw, cnf.colors[int(cls_pred)])
+		# send to board
+                send_struct = struct.pack('10sffffffff', f'D{frame}-{count}'.encode(), x.item(), y.item(), w.item(), l.item(), yaw.item(), conf.item(), cls_conf.item(), cls_pred.item())
+                print(x.item(), y.item(), w.item(), l.item(), yaw.item(), conf.item(), cls_conf.item(), cls_pred.item())
+                
+                #detections_list.append([x.item(), y.item(), w.item(), l.item(), yaw.item(), conf.item(), cls_conf.item(), cls_pred.item()])
+                count = count + 1
+                detections_list.append(send_struct)
+            # cls_pred value: 0 (Car), 1 (Pedestrian), 2 (Cyclist)
+            #print(detections_list)
+            # send to board
+            for i in range(len(detections)):
+                boardSock.sendto(detections_list[i], board_add)
+            frame = frame + 1
+            
+        
+        '''
+        img2d = cv2.imread(img_paths[0])
+        calib = kitti_utils.Calibration(img_paths[0].replace(".png", ".txt").replace("image_2", "calib"))
+        objects_pred = predictions_to_kitti_format(img_detections, calib, img2d.shape, opt.img_size)
+
+        #img2d = mview.show_image_with_boxes(img2d, objects_pred, calib, False)
+
+        cv2.imshow("bev img", RGB_Map)
+        #cv2.imshow("img2d", img2d)
+
+        if cv2.waitKey(0) & 0xFF == 27:
+            break
+        '''
+    boardSock.close()