def cache_cfg_urls(): """Download URLs in the config, cache them locally, and rewrite cfg to make use of the locally cached file. """ __C.TRAIN.WEIGHTS = cache_url(__C.TRAIN.WEIGHTS, __C.DOWNLOAD_CACHE) __C.TEST.WEIGHTS = cache_url(__C.TEST.WEIGHTS, __C.DOWNLOAD_CACHE) __C.TRAIN.PROPOSAL_FILES = tuple( cache_url(f, __C.DOWNLOAD_CACHE) for f in __C.TRAIN.PROPOSAL_FILES ) __C.TEST.PROPOSAL_FILES = tuple( cache_url(f, __C.DOWNLOAD_CACHE) for f in __C.TEST.PROPOSAL_FILES )
def generate_predicitions_from_frames(images, config_file, weights): """Generator yields inferred boxes and keypoints for each image in a provided iterable of images Args: images: iterable images config_file: Detectron configuration file weights: pretrained weights Returns: yields i, im, cls_boxes, cls_segms, cls_keyps """ logger = logging.getLogger(__name__) merge_cfg_from_file(config_file) cfg.NUM_GPUS = 1 weights = cache_url(weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights) for i, im in enumerate(images): logger.info("Processing frame {}".format(i)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info("Inference time: {:.3f}s".format(time.time() - t)) for k, v in timers.items(): logger.info(" | {}: {:.3f}s".format(k, v.average_time)) if i == 0: logger.info( "Note: inference on the first image will be slower than the " "rest (caches and auto-tuning need to warm up)" ) yield i, im, cls_boxes, cls_segms, cls_keyps
def check_args(args): assert ((args.rpn_pkl is not None and args.rpn_cfg is not None) or (args.rpn_pkl is None and args.rpn_cfg is None)) if args.rpn_pkl is not None: args.rpn_pkl = cache_url(args.rpn_pkl, cfg.DOWNLOAD_CACHE) assert os.path.exists(args.rpn_pkl) assert os.path.exists(args.rpn_cfg) if args.models_to_run is not None: assert len(args.models_to_run) % 2 == 0 for i, model_file in enumerate(args.models_to_run): if len(model_file) > 0: if i % 2 == 0: model_file = cache_url(model_file, cfg.DOWNLOAD_CACHE) args.models_to_run[i] = model_file assert os.path.exists(model_file), \ '\'{}\' does not exist'.format(model_file)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] pool = mp.Pool(mp.cpu_count()) func = partial(process_image, model, args) pool.map(func, [im_name for im_name in im_list]) pool.close() pool.join()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): output_image_dir = os.path.join(args.output_dir, 'images') out_name = os.path.join( output_image_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext)) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') # vis_utils.vis_one_image( # im[:, :, ::-1], # BGR -> RGB for visualization # im_name, # output_image_dir, # cls_boxes, # cls_segms, # cls_keyps, # dataset=dummy_coco_dataset, # box_alpha=0.3, # show_class=True, # thresh=0.7, # kp_thresh=2, # ext=args.output_ext, # out_when_no_box=args.out_when_no_box #) _write_to_txt(cls_boxes, cls_segms, cls_keyps, im_name, dummy_coco_dataset)
def __init__(self, cfg_path, weights_path=""): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 weights = cache_url(weights_path, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) self.model = infer_engine.initialize_model_from_cfg(weights) self.dummy_coco_dataset = dummy_datasets.get_coco_dataset()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 4 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) # model = infer_engine.initialize_model_from_cfg(args.weights,gpu_id=3) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] len_str = str(len(os.listdir(args.im_or_folder))) for i, im_name in enumerate(im_list): print('~~~~~~~~~~~~~~~~~' + str(i) + '/' + len_str + "~~~~~~~~~~~~~~~~~~~~~") out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.jpg')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( #此处输出的cls_boxes包含类别信息 model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') # ipdb.set_trace() # print(cls_boxes) # print(cls_segms) # print(cls_keyps) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.5, kp_thresh=2, ext='jpg')
def main(args): #logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cam = cv2.VideoCapture(0) # Set Texture Tex_Atlas = cv2.imread( 'DensePoseData/demo_data/texture_from_SURREAL.png')[:, :, ::-1] / 255.0 #Tex_Atlas = cv2.imread('DensePoseData/demo_data/texture_atlas_200.png')[:,:,::-1] TextureIm = np.zeros([24, 200, 200, 3]) # for i in range(4): for j in range(6): TextureIm[(6 * i + j), :, :, :] = Tex_Atlas[(200 * j):(200 * j + 200), (200 * i):(200 * i + 200), :] while True: if cv2.waitKey(1) & 0xFF == ord('q'): break retval, im = cam.read() #imsmall = cv2.resize(im, None, fx=0.5, fy=0.5) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=None) iuvout, indsout = vis_utils.vis_webcam(im, cls_boxes, cls_segms, cls_keyps, cls_bodys, thresh=0.9, kp_thresh=2, dataset=dummy_coco_dataset, show_class=True) iuvout, indsout = vis_utils.vis_webcam( im, boxes=cls_boxes, segms=cls_segms, keypoints=cls_keyps, body_uv=cls_bodys, thresh=0.9, kp_thresh=2, dpi=200, box_alpha=0.3, dataset=dummy_coco_dataset, show_class=True, ) #cv2.imshow('input', im) texout = TransferTexturePure(TextureIm, im, iuvout) cv2.imshow('output', texout)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() submit_result = [] result_file_name = 'detectron_val_result.txt' if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') result = vis_utils.vis_one_image_bbox( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) if result: submit_result.extend(result) logger.info('Image {}.'.format(i)) # Write file with open(result_file_name, 'wb') as result_file: for item in submit_result: result_file.write("%s\n" % item) logger.info( 'The result file has been written in {}.'.format(result_file_name))
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext) ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=args.thresh, kp_thresh=args.kp_thresh, ext=args.output_ext, out_when_no_box=args.out_when_no_box )
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(args.weights) start = timeit.default_timer() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] # extract bboxes from bottom-up attention model image_bboxes = {} if args.bbox_file is not None: image_bboxes = extract_bboxes(args.bbox_file) count = 0 if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) for i, im_name in enumerate(im_list): im_base_name = os.path.basename(im_name) image_id = int(im_base_name.split(".")[0].split("_")[-1]) # for COCO if image_id % args.total_group == args.group_id: bbox = image_bboxes[image_id] if image_id in image_bboxes else None im = cv2.imread(im_name) if im is not None: outfile = os.path.join(args.output_dir, im_base_name.replace('jpg', 'npy')) lock_folder = outfile.replace('npy', 'lock') if not os.path.exists(lock_folder) and os.path.exists(outfile): continue if not os.path.exists(lock_folder): os.makedirs(lock_folder) result = get_detections_from_im(cfg, model, im, image_id, args.feat_name, args.min_bboxes, args.max_bboxes, bboxes=bbox) np.save(outfile, result) os.rmdir(lock_folder) count += 1 if count % 100 == 0: end = timeit.default_timer() epoch_time = end - start print('process {:d} images after {:.1f} s'.format( count, epoch_time))
def infer(par,thresh): logger = logging.getLogger(__name__) merge_cfg_from_file(par['config_path']) cfg.NUM_GPUS = 1 par['weight_path'] = cache_url(par['weight_path'], cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(par['weight_path']) if os.path.isdir(par['input_img_path']): im_list = glob.iglob(par['input_img_path'] + '/*.jpg') else: im_list = [par['input_img_path']] count = 0 t_total = 0 np.set_printoptions(suppress=True) #numpy不以科学计数法输出 for i, im_name in enumerate(im_list):# i为计数,im_name为图像路径 out_name = os.path.join( par['output_xml_path'], '{}'.format(os.path.basename(im_name.rstrip(".jpg")) + '.xml') ) #logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) w = float(im.shape[1]) h = float(im.shape[0]) #开始计时 timers = defaultdict(Timer) t_start = time.time() with c2_utils.NamedCudaScope(par['gpu_id']): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) if boxes is not None: boxes = np.array(boxes) # 坐标归一化 ↓ # boxes[:,0:4] = boxes[:,0:4]/np.array([col,row,col,row]) # boxes = np.maximum(boxes,0) # boxes = np.minimum(boxes,1) classes_ = np.array(classes,dtype=int) classes_temp = classes_.reshape(1,-1) classes = np.transpose(classes_temp) res = np.hstack((classes,boxes)) # res中,第一列为类别,2~5列为坐标,第六列为分数 res = res[res[:,-1]>thresh] else: res = [] #结束计时 t_end = time.time() t_total = t_total + (t_end-t_start) count = count + 1 make_xml_file(par,res,w,h,out_name) print("Average detection time:",int(1000*t_total/count),"ms/img")
def check_args(args): assert ( (args.rpn_pkl is not None and args.rpn_cfg is not None) or (args.rpn_pkl is None and args.rpn_cfg is None) ) if args.rpn_pkl is not None: args.rpn_pkl = cache_url(args.rpn_pkl, cfg.DOWNLOAD_CACHE) assert os.path.exists(args.rpn_pkl) assert os.path.exists(args.rpn_cfg) if args.models_to_run is not None: assert len(args.models_to_run) % 2 == 0 for i, model_file in enumerate(args.models_to_run): if len(model_file) > 0: if i % 2 == 0: model_file = cache_url(model_file, cfg.DOWNLOAD_CACHE) args.models_to_run[i] = model_file assert os.path.exists(model_file), \ '\'{}\' does not exist'.format(model_file)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() ''' add onboard cam support ''' cam = cv2.VideoCapture("nvcamerasrc ! video/x-raw(memory:NVMM), width=(int)1280, height=(int)720,format=(string)I420, framerate=(fraction)30/1 ! nvvidconv flip-method=0 ! video/x-raw, format=(string)BGRx ! videoconvert ! video/x-raw, format=(string)BGR ! appsink") if cam.isOpened(): print("camara open succeded") im_name = "Detection" while True: _, im = cam.read(); timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) ''' for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) ''' vis_utils.vis_cam_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 ) """ key=cv2.waitKey(10) if key == 27: # Check for ESC key cv2.destroyAllWindows() break ; """ else: print("camera open failed")
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) while True: reply = {} # Wait for next request from client im,extra = zmqa.recv(socket) if extra is not None and 'fname' in extra: print("Received request %s" % extra) reply['fname']=extra['fname'] else: print("Received request %s" % extra) reply['fname'] = 'input.jpg' # set file name im_name=reply['fname'] timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext) ) masks=do_one_image_opencv( im, # BGR -> RGB for visualization cls_boxes, cls_segms, cls_keyps, thresh=0.7, reply=reply ) zmqa.send(socket, masks,extra=reply)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() # load match scene match_scene_dict = pickle.load(open('{}/pkl/match_scene_intervals_dict.pkl'.format(args.data_dir), 'rb')) HW_foreground = set() JZ_foreground = set() for match in match_scene_dict['HW_foreground']: for fid in range(match[1], match[2]): HW_foreground.add(fid) for match in match_scene_dict['JZ_foreground']: for fid in range(match[1], match[2]): JZ_foreground.add(fid) # detect frame cap = cv2.VideoCapture('{}/videos/{}'.format(args.data_dir, args.input_video)) result_list = [] fid = 0 ret = True # create dir for player in ['HW', 'JZ']: dir = '{data_dir}/image/img_{player}'.format(data_dir=args.data_dir, player=player) if not os.path.exists(dir): os.makedirs(dir) dir = '{data_dir}/image/densepose_{player}'.format(data_dir=args.data_dir, player=player) if not os.path.exists(dir): os.makedirs(dir) vid = 65 while ret: if fid % 1000 == 0: print("Inferring frame %d" % fid) ret, image = cap.read() if fid in HW_foreground or fid in JZ_foreground: player = 'HW' if fid in HW_foreground else 'JZ' img_path = '{data_dir}/image/img_{player}/img_{vid}_{fid}_{player}.jpg'.format(data_dir=args.data_dir, player=player, vid=vid, fid=fid) pose_path = '{data_dir}/image/densepose_{player}/densepose_{vid}_{fid}_{player}.jpg'.format(data_dir=args.data_dir, player=player, vid=vid, fid=fid) result_one_image = infer_one_frame(image, model, img_path, pose_path) result_one_image['foreground'] = player result_one_image['fid'] = fid result_list.append(result_one_image) fid += 1 # if len(result_list) > 100: # break pickle.dump(result_list, open('{}/pkl/result.pkl'.format(args.data_dir), 'wb'), protocol=2)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): vid = im_name.split("/")[1] output_dir = args.output_dir + vid try: os.mkdir(output_dir) except OSError: pass out_name = os.path.join( output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')) if os.path.exists(out_name): continue logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def get_model(): workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) merge_cfg_from_file( '/home/bryan/code/detectron/configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml' ) cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) DOWNLOAD_CACHE = '/tmp/detectron-download-cache' weights_url = 'https://s3-us-west-2.amazonaws.com/detectron/35861858/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml.02_32_51.SgT4y1cO/output/train/coco_2014_train:coco_2014_valminusminival/generalized_rcnn/model_final.pkl' weights = cache_url(weights_url, DOWNLOAD_CACHE) return infer_engine.initialize_model_from_cfg(weights)
def main(args): #ros initialization rospy.init_node('get_image', anonymous=True) args.im_or_folder = get_image() while not rospy.is_shutdown(): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() # set im list to be the ros image im = args.im_or_folder timers = defaultdict(Timer) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) # calls the method that performs actual detection and inference fig = vis_utils.vis_one_image_opencv( im[:, :, ::-1], # BGR -> RGB for visualization cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, show_class=True, thresh=args.thresh, kp_thresh=args.kp_thresh, ) # img is rgb, convert to opencv's default bgr img = cv2.cvtColor(fig, cv2.COLOR_RGB2BGR) image_publisher = rospy.Publisher('detectron_output', Image, queue_size=10) brdg = CvBridge() image_publisher.publish(brdg.cv2_to_imgmsg(img, "bgr8")) try: start_time = time.time() print(time.time() - start_time) main(args) except KeyboardInterrupt: print("shutting down") cv2.destroyAllWindows()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() print("capturing video " + args.input) cap = cv2.VideoCapture(args.input) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # pdb.set_trace() grab = 1 if (cap.isOpened() == False): print("Error opening video stream or file") exit while (cap.isOpened() and grab <= total_frames): grab += 1 ret_val, im = cap.read() #skips intermediate frames #if grab%2 !=0: # continue #uncomment to resize image #im = cv2.resize(im, (int(1280/1),int(720/1))) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=timers) output_name = 'frame' + str(grab).zfill(4) + '.mp4' print("| Analysed frame {0} / {1} in {2}ms".format( grab, total_frames, int(1000. * (time.time() - t)))) #print('\t | Inference time: {:.3f}s'.format(time.time() - t)) #for k, v in timers.items(): # print('\t | {}: {:.3f}s'.format(k, v.average_time)) ret = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization output_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=False, thresh=0.7, kp_thresh=2) cap.release() cv2.destroyAllWindows()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() h5py_file_path = ('/media/hdd1/tanya/open-pose/' 'paired_filenames512_image_keypoints512_main.h5') hf = h5py.File(h5py_file_path, 'r') IUV_image_list = [] for i in range(len(hf['images'])): im = hf['images'][i] timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) IUV_image = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization 'dummy', args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) IUV_image_list.append(IUV_image) IUV_images_final = np.stack(IUV_image_list, 0) with h5py.File('./paired_filenames512_image_keypoints_withIUV.h5', 'w') as f: f.create_dataset('images', data=np.array(hf['images'])) f.create_dataset('keypoints', data=np.array(hf['keypoints'])) f.create_dataset('IUV', data=IUV_images_final)
def setup(self): c2_utils.import_detectron_ops() cv2.ocl.setUseOpenCL(False) merge_cfg_from_file( '/DensePose/configs/DensePose_ResNet101_FPN_s1x-e2e.yaml') cfg.NUM_GPUS = 1 weights = cache_url( 'https://s3.amazonaws.com/densepose/DensePose_ResNet101_FPN_s1x-e2e.pkl', cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(weights, 1) dummy_coco_dataset = dummy_datasets.get_coco_dataset() return model
def main(args): logger = logging.getLogger(__name__) pdb.set_trace() merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] print(im_list) for i, im_name in enumerate(im_list): im_basename = os.path.basename(im_name) out_name = os.path.join( args.output_dir, '{}'.format(im_basename + '.' + args.output_ext)) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) result_file = os.path.join(args.output_dir, im_basename + '_bbox.pkl') with open(result_file, 'wb') as f: boxes, _, _, _ = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) print(boxes.shape) pickle.dump(cls_boxes, f) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)')
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() zmq_video = args.source == "zmq" frameId = 0 if zmq_video: context = zmq.Context() socket = context.socket(zmq.REP) socket.bind("tcp://*:7001") else: # From virtual camera video and its associated timestamp file on Drive PX2,e.g."./lane/videofilepath.h264" cap = cv2.VideoCapture(args.source) while True: if zmq_video: try: message = socket.recv() print("Received message length:" + str(len(message)) + " type:" + str(type(message))) socket.send("ok") position = message.find(ZMQ_SEPER, 0, 100) frameId = message[:position] message = message[position + len(ZMQ_SEPER):] img_np = np.fromstring(message, np.uint8) img_np = img_np.reshape((400, 1400, 3)) print("nparr type:" + str(type(img_np)) + " shape:" + str(img_np.shape)) ret = True except KeyboardInterrupt: print("interrupt received, stopping...") socket.close() context.term() ret = False cap.release() else: ret, img_np = cap.read() frameId += 1 # read completely or raise exception if not ret: print("cannot get frame") break hanle_frame(args, frameId, img_np, logger, model, dummy_coco_dataset)
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) dataset_name = cfg.TEST.DATASETS[0] dummy_coco_dataset = JsonDataset(dataset_name) # dummy_coco_dataset = dummy_datasets.get_paris_dataset() vid_dir = '/coco/paris_dataset/PARIS_demo.mp4' cap = cv2.VideoCapture(vid_dir) ret, im = cap.read() count = 0 while ret: im_name = str(count) out_name = os.path.join(args.output_dir, '{}'.format(str(count) + '.jpg')) logger.info('Processing frame -> {}'.format(count)) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) vis_im = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) # cv2.imshow('frame', vis_im) # cv2.waitKey(10) ret, im = cap.read() count += 1 cap.release() cv2.destroyAllWindows()
def setup(): global dummy_coco_dataset cfg_file = 'configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml' weights = 'https://dl.fbaipublicfiles.com/detectron/35861858/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml.02_32_51.SgT4y1cO/output/train/coco_2014_train:coco_2014_valminusminival/generalized_rcnn/model_final.pkl' merge_cfg_from_file(cfg_file) cfg.NUM_GPUS = 1 weights = cache_url(weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() return model
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg(args.weights) output = open(args.output_file, "w+") if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): logger.info('Processing {}'.format(i)) output.write(im_name[-40:] + "\n") im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') thresh = 0.2 if isinstance(cls_boxes, list): boxes, classes = convert_from_cls_format(cls_boxes) if type(boxes) == np.ndarray: areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]) sorted_inds = np.argsort(-areas) for i in sorted_inds: bbox = boxes[i, :4] score = boxes[i, -1] if score < thresh: continue else: output.write( str(bbox[0]) + " " + str(bbox[1]) + " " + str(bbox[2]) + " " + str(bbox[3]) + " " + str(score) + "\n") output.close()
def inference(cfg_path, weights, img_pillow, output_dir): logger = logging.getLogger(__name__) merge_cfg_from_file(cfg_path) #print( "cfg : ", cfg ) assert_and_infer_cfg(cache_urls=False, make_immutable=False) cfg.NUM_GPUS = 1 weights = cache_url(weights, cfg.DOWNLOAD_CACHE) model = infer_engine.initialize_model_from_cfg(weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() im_name = "test" #img_cv = cv2.imread(im_name) img_np = np.asarray(img_pillow) img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img_cv, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) vis_utils.vis_one_image( img_cv[:, :, ::-1], # BGR -> RGB for visualization im_name, output_dir, cls_boxes, cls_segms, cls_keyps, cls_bodys, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2) IUV_SaveName = os.path.basename(im_name).split('.')[0] + '_IUV.png' INDS_SaveName = os.path.basename(im_name).split('.')[0] + '_INDS.png' iuv_pillow = Image.open(os.path.join(output_dir, '{}'.format(IUV_SaveName))) inds_pillow = Image.open( os.path.join(output_dir, '{}'.format(INDS_SaveName))) return iuv_pillow, inds_pillow
def main(args): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, 'detection_' + '{}'.format(os.path.basename(im_name)) ) print('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) #print('Inference time: {:.3f}s'.format(time.time() - t)) #for k, v in timers.items(): # print(' | {}: {:.3f}s'.format(k, v.average_time)) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization out_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=args.thresh, kp_thresh=args.kp_thresh, out_when_no_box=args.out_when_no_box )
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext) else: im_list = [args.im_or_folder] for i, im_name in enumerate(im_list): #if i > 10: # continue out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name)[:-len(args.image_ext)] + 'mat') ) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) boxes, segms, keyps, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) if boxes is None: continue segms = vis_utils.mask_util.decode(segms) valid_inds = np.greater(boxes[:, 4], 0.5) boxes = boxes[valid_inds, :] segms = segms[:, :, valid_inds] classes = np.array(classes)[valid_inds] class_names = np.asarray(([coco_to_pascal_name(coco_classes[c-1]) for c in classes]), dtype='object') sio.savemat(out_name, {'masks': segms, 'boxes': boxes, 'classes': class_names});
def __init__(self, score_threshold): self.score_threshold = score_threshold workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) merge_cfg_from_file(config_path) cfg.NUM_GPUS = 1 weights_path = cache_url(weights_url, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, 'Models that require precomputed proposals are not supported' self.model = infer_engine.initialize_model_from_cfg(weights_path) self.dummy_coco_dataset = dummy_datasets.get_coco_dataset()
def __init__(self, args): self.logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' self.model = infer_engine.initialize_model_from_cfg(args.weights) self.coco_dataset = get_coco_dataset() self.image_srv = rospy.Service('infer_image', MaskInfer, self.infer_image) self.thresh = args.thresh self.dir = args.dir
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 if "mot-classes" in args.opts: dummy_dataset = dummy_datasets.get_mot_dataset() cfg.NUM_CLASSES = 14 else: dummy_dataset = dummy_datasets.get_coco_dataset() cfg.NUM_CLASSES = 81 for i, weights_file in enumerate(args.weights_list): args.weights_list[i] = cache_url(weights_file, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) logger.info('Testing with config:') logger.info(pprint.pformat(cfg)) preffix_list = args.preffix_list if len(args.preffix_list) \ else [""] * len(args.weights_list) model = infer_engine.initialize_mixed_model_from_cfg( args.weights_list, preffix_list=preffix_list) # Initialize tracking accumulator tracking = Tracking(args.thresh, cfg.TRCNN.MAX_BACK_TRACK) vis = { "output-dir": args.output_dir, "dummy-dataset": dummy_dataset, "show-class": "show-class" in args.opts, "show-track": "show-track" in args.opts, "thresh": args.thresh, "kp-thresh": args.kp_thresh, "track-thresh": args.track_thresh, "n-colors": args.n_colors, } # Load proposals if specified if args.proposals is not None: proposals = pickle.load(open(args.proposals, 'r')) else: proposals = None # Run inference infer_track_sequence(model, args.im_dir, tracking, vis=vis, det_file=args.output_file, proposals=proposals, mot=("all-dets" not in args.opts))
def main(args): glob_keypoints = [] logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE) assert_and_infer_cfg(cache_urls=False) assert not cfg.MODEL.RPN_ONLY, \ 'RPN models are not supported' assert not cfg.TEST.PRECOMPUTED_PROPOSALS, \ 'Models that require precomputed proposals are not supported' model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.im_or_folder): im_list = glob.iglob(args.im_or_folder + '/*' + '.png') else: im_list = [args.im_or_folder] im_list = sorted(im_list) for i, im_name in enumerate(im_list): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.' + args.output_ext) ) logger.info('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers ) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if i == 0: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)' ) vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization im_name, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=args.thresh, kp_thresh=args.kp_thresh, ext=args.output_ext, out_when_no_box=args.out_when_no_box ) cls_boxes_np = np.asarray(cls_boxes) cls_boxes_prob = cls_boxes_np[1][:,4] idx_max_prob = np.argmax(cls_boxes_prob) cls_keyps_max_prob = cls_keyps[1][idx_max_prob] pose_x_y_prob_after_softmax = cls_keyps_max_prob[[0,1,3]] glob_keypoints.append(np.transpose(pose_x_y_prob_after_softmax)) dictionarry_keypoints={'S1': {'Directions 1' : np.asarray([glob_keypoints])}} metadata = {'layout_name': 'h36m', 'num_joints': 17, 'keypoints_symmetry': [[4, 5, 6, 11, 12, 13], [1, 2, 3, 14, 15, 16]]} #np.savez(os.path.join('/home/narvis/Dev/VideoPose3D/data', "data_2d_detections.npz"), metadata=metadata, positions_2d=dictionarry_keypoints) np.savez(os.path.join(args.output_dir, "data_2d_detections.npz"), metadata=metadata, positions_2d=dictionarry_keypoints)