from nuscenes.nuscenes import NuScenes from nuscenes.nuscenes import NuScenesExplorer # import tensorflow as tf import cv2 import numpy as np from nuscenes.image_utils import ImageProcessing as ip root = 'D:/dataset/v1.0-mini' # root = '/home/vincent/Data/v1.0-mini' nusc = NuScenes(version='v1.0-mini', dataroot=root, verbose=True) # get night scenes night_scene = nusc.list_night() # Get sensor data sensor_token = nusc.get_sensor_token_list(night_scene[0]) # cv2读取图片颜色发生变化 # sensor_token = nusc.get_sensor_token_list('scene-0061') im = ip(sensor_token[0], nusc, min_size=900) # Render ground truth # im.render_arbitrary() # im.render_arbitrary1() # Render prediction # im.render_rectangle(im.control_points_list) # cell_class, corner_point_deta= im.annotations_in_net() im = ip('2d35f62a9daf41a18c15c7a946b0d141', nusc, min_size=900) im.render_arbitrary() print(len(im.control_points_list)) print(im.control_points_list)
class provider(object): """provide multi threads API for reading data #### multi thread #### ## multi thread ## ###################### ## ################## ## ####################### ###################### ## ################## ## ####################### ###read single data### ####### ### batch data ### ####### ### load batch data ### ###################### ## ################## ## ####################### ###################### ## ################## ## ####################### Example 1: dt = provider(batch_size=10, for_what="train", whether_aug=True) for step in range(100): imgs, labels, t_bboxes = dt.load_batch() ## do sth ## dt = provider(batch_size=10, for_what="predict", whether_aug=True) ##also use aug to predict for step in range(100): imgs, corner_bboxes = dt.load_batch() ## do sth ## Example 2: with provider(batch_size=10,for_what="train") as pd: imgs, labels, t_bboxes = pd.load_batch() ## do sth ## with provider(batch_size=10,for_what="test") as pd: imgs, corner_bboxes = pd.load_batch() ## do sth ## """ __imgs_name = None __for_what = None __whether_aug = None __data_queue = None __batch_queue = None __read_threads = None __batch_threads = None __threads_name = None def __init__(self, for_what, batch_size=1, whether_aug=False): """init Args: batch_size: the size of a batch for_what: indicate train or test, must be "train" or "test" whether_aug: whether to augument the img """ ## assert batch_size > 0 assert type(whether_aug) == bool self.__mini_size = 416 self.__whether_aug = whether_aug if for_what not in ["train", "predict", "evaluate"]: raise ValueError( 'pls ensure for_what must be "train","predict" or "evaluate"') else: self.__for_what = for_what data_root = os.path.dirname(__file__) if for_what == "train": ## load the imgs file name ## # match = os.path.join(data_root, pic_train_dir_str + "*.jpg") # # self.__imgs_name = glob.glob(match) # if len(self.__imgs_name) == 0: # raise ValueError("can not found the imgs, pls " + # "check pic_train_dir and ensure img format must be jpeg") # self.__label_dir = os.path.join(data_root, label_train_dir_str) ########################## root = 'D:/dataset/v1.0-mini' root = '/home/vincent/Data/v1.0-mini' self.nusc = NuScenes(version='v1.0-mini', dataroot=root, verbose=True) # get night scenes self.night_scene = self.nusc.list_night() # Get sensor data self.sensor_token = self.nusc.get_sensor_token_list( self.night_scene[0]) else: ## load the imgs file name ## # match = os.path.join(data_root, pic_test_dir_str + "*.jpg") # self.__imgs_name = glob.glob(match) # if len(self.__imgs_name) == 0: # raise ValueError("can not found the imgs, pls " + # "check pic_test_dir and ensure img format must be jpeg") # self.__label_dir = os.path.join(data_root, label_test_dir_str) pass if for_what in ["train", "predict"]: ## set batch size and start queue ## self.__batch_size = batch_size self.__threads_name = [] self.__start_read_data(batch_size=self.__batch_size) self.__start_batch_data(batch_size=self.__batch_size) logger.info('Start loading queue for %s' % (for_what)) else: ## for evaluation ## # assert whether_aug == False ## when evaluate, aug must be false # self.__imgs_name_que = collections.deque(self.__imgs_name) # logger.info('For evaluation') pass def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if exc_type != None: if self.__threads_name != None: if len(self.__threads_name) > 0: exist_threads = threading.enumerate() exist_threads_name = [ exist_thread.name for exist_thread in exist_threads ] for thread_name in self.__threads_name: if thread_name not in exist_threads_name: names = str.split(thread_name, "_") if names[0] == "read": restart_thread = threading.Thread( target=self.__send_data) restart_thread.setName(thread_name) restart_thread.setDaemon(True) restart_thread.start() print("restart a down thread") return True elif names[0] == "batch": restart_thread = threading.Thread( target=self.__batch_data, args=(self.__batch_size, )) restart_thread.setName(thread_name) restart_thread.setDaemon(True) restart_thread.start() print("restart a down thread") return True print(exc_type) print(exc_val) print(exc_tb) exit(1) def load_data_eval(self): """Traversing the test set in sequence Return: img: one img with shape (h, w, c), if end, None bboxes: shape is (n, 4), if end, None """ try: ##get img name img_name = self.__imgs_name_que.popleft() ##get corresponding anotation name filename = os.path.basename(img_name) basefile = filename.split(".")[0] label_name = os.path.join(self.__label_dir, (basefile + '.xml')) img, bboxes = self.__read_one_sample(img_name, label_name) img, bboxes = train_tools.normalize_data(img, bboxes, config.img_size) return img, bboxes, filename except IndexError: return None, None, None def load_batch(self): """get the batch data Return: if dataset is for training, return imgs, labels, t_bboxes: imgs: a list of img, with the shape (h, w, c) labels: a list of labels, with the shape (grid_h, grid_w, pboxes_num, 1) 0 is background, 1 is object t_bboxes: a list of t_bboxes with the shape (grid_h, grid_w, pboxes_num, 4) if dataset is for test, return imgs, corner_bboxes imgs: a list of img, with the shape (h, w, c) corner_bboxes: a list of bboxes, with the shape (?, 4), encoded by [ymin, xin, ymax, xmax] """ batch_data = self.__batch_queue.get() if self.__for_what == "train": ## return imgs, lebels, t_bboxes ## return batch_data[0], batch_data[1], batch_data[2] else: ## return imgs , corner_bboxes ## # return batch_data[0], batch_data[1] pass def stop_loading(self): """to kill all threads """ threads = self.__read_threads + self.__batch_threads for thread in threads: self.__async_raise(thread.ident, SystemExit) pass def __start_read_data(self, batch_size, thread_num=4, capacity_scalar=2): """ start use multi thread to read data to the queue Args: thread_num: the number of threads used to read data batch_size: the buffer size which used to store the data """ self.__read_threads = [] maxsize = np.maximum(batch_size * capacity_scalar, 5) self.__data_queue = queue.Queue(maxsize=maxsize) ## start threads for i in range(thread_num): thread = threading.Thread(target=self.__send_data) thread.setDaemon(True) thread.setName("read_thread_id%d" % (i)) self.__threads_name.append("read_thread_id%d" % (i)) thread.start() self.__read_threads.append(thread) def __start_batch_data(self, batch_size, thread_num=4, queue_size=5): """ start the threads to batch data into the batch_queue Args: batch_size: the batch size. thread_num: the number of threads queue_size: the max batch queue length """ assert queue_size > 0 self.__batch_threads = [] self.__batch_queue = queue.Queue(queue_size) for i in range(thread_num): thread = threading.Thread(target=self.__batch_data, args=(batch_size, )) thread.setDaemon(True) thread.setName("batch_thread_id%d" % (i)) self.__threads_name.append("batch_thread_id%d" % (i)) thread.start() self.__batch_threads.append(thread) def __batch_data(self, batch_size): """dequeue the data_queue and batch the data into a batch_queue """ first = True batch_container_list = [] while True: for i in range(batch_size): data_list = self.__data_queue.get() if first: ## init the batch_list ## for i in range(len(data_list)): batch_container_list.append([]) first = False for batch_container, data_item in zip(batch_container_list, data_list): batch_container.append(data_item) ## put the batch data into batch_queue ## self.__batch_queue.put(copy.deepcopy(batch_container_list)) for batch_container in batch_container_list: batch_container.clear() def __send_data(self): """ a single thread which send a data to the data queue """ priori_bboxes = config.priori_bboxes / config.img_size while True: # img_name = random.sample(self.__imgs_name, 1)[0] # filename = os.path.basename(img_name) # basefile = filename.split(".")[0] # # label_name = os.path.join(self.__label_dir,(basefile+".xml")) # # img, bboxes = self.__read_one_sample(img_name,label_name) sensor_token_pick = random.sample(self.sensor_token, 1)[0] im = ip(sensor_token_pick, self.nusc, mini_size=self.__mini_size) ## resize img and normalize img and bboxes## if self.__for_what == "train": cell_class, corner_point_deta = im.annotations_in_net() self.__data_queue.put( [im.image, cell_class, corner_point_deta]) else: # if self.__whether_aug: # img, bboxes = test_tools.img_aug(img, bboxes) # if len(bboxes) == 0: # ## sometimes aug func will corp no person## # #logger.warning("No person img, abandoned...") # continue # img, bboxes = train_tools.normalize_data(img, bboxes, config.img_size) # self.__data_queue.put([img, bboxes]) pass def __read_one_sample(self, img_name, label_name): """read one sample Args: img_name: img name, like "/usr/img/image001.jpg" label_name: the label file responding the img_name, like "/usr/label/image001.xml" Return: An ndarray with the shape [img_h, img_w, img_c], bgr format An ndarray with the shape [?,4], which means [ymin, xmin, ymax, xmax] """ #cv2.imdecode(np.fromfile(image_path, dtype=np.uint8), -1) img = cv2.imread(img_name) DOMTree = xml.dom.minidom.parse(label_name) collection = DOMTree.documentElement objs = collection.getElementsByTagName("object") labels = [] for obj in objs: obj_type = obj.getElementsByTagName('name')[0].childNodes[0].data if obj_type == "person": bbox = obj.getElementsByTagName('bndbox')[0] ymin = bbox.getElementsByTagName('ymin')[0].childNodes[0].data xmin = bbox.getElementsByTagName('xmin')[0].childNodes[0].data ymax = bbox.getElementsByTagName('ymax')[0].childNodes[0].data xmax = bbox.getElementsByTagName('xmax')[0].childNodes[0].data label = np.array([int(ymin), int(xmin), int(ymax), int(xmax)]) labels.append(label) labels = np.stack(labels, axis=0) return img, labels def __async_raise(self, tid, exctype): """raises the exception, performs cleanup if needed""" tid = ctypes.c_long(tid) if not inspect.isclass(exctype): exctype = type(exctype) res = ctypes.pythonapi.PyThreadState_SetAsyncExc( tid, ctypes.py_object(exctype)) if res == 0: raise ValueError("invalid thread id") elif res != 1: # """if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect""" ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None) raise SystemError("PyThreadState_SetAsyncExc failed")