def detect(self, im, id): timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, im, None, timers=timers) self.logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in timers.items(): self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) imsw = vis_utils.vis_one_image_opencv(im, cls_boxes, cls_segms, cls_keyps, self.confidence, 2, show_box=True, dataset=self.dummy_coco_dataset, show_class=True) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) bboxes = BBoxDetArray() bboxes.header = std_msgs.msg.Header() if boxes is not None: for i in range(len(boxes)): box = boxes[i][0:4] score = boxes[i][4] cls = self.dummy_coco_dataset.classes[classes[i]] if (score >= self.confidence): bbox = BBox(box[0], box[1], box[2], box[3]) bbox_det = BBoxDet(bbox, score, cls) bboxes.bboxes.append(bbox_det) return imsw, bboxes
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) model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, timers=timers) image = vis_utils.vis_one_image_opencv(np.array(frame), cls_boxes, cls_segms, cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, show_class=True) cv2.imshow('camera', image) if cv2.waitKey(1) & 0xFF == ord('q'): break print("Time:", time.time() - t) cap.release() cv2.destroyAllWindows()
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.TEST.WEIGHTS = args.weights cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = infer_engine.initialize_model_from_cfg() 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) + '.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)') t1 = time.time() im = vis_utils.vis_one_image_opencv(im, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.7, kp_thresh=2, show_box=True, dataset=dummy_coco_dataset, show_class=True) # 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.7, # kp_thresh=2 # ) t2 = time.time() - t1 print("vis time %f ms" % (t2 * 1000)) cv2.imwrite( args.output_dir + '/' + im_name.split('/')[-1].split('.')[0] + '.jpg', im)
def _vis_single_frame(im, cls_boxes_i, cls_segms_i, cls_keyps_i, cls_tracks_i, thresh): res = vis_utils.vis_one_image_opencv( im, cls_boxes_i, segms=cls_segms_i, keypoints=cls_keyps_i, tracks=cls_tracks_i, thresh=thresh, show_box=True, show_class=False, linewidth = 1) if res is None: return im return res
def test(model, dataset, start_ind, end_ind, logger): all_boxes = [] all_segms = [] all_parss = [] all_pscores = [] num_img = cfg.TEST.IMS_PER_GPU with torch.no_grad(): for i in range(start_ind, end_ind, num_img): logger.iter_tic() logger.data_tic() ims = [] image_ids = [] for j in range(i, i + num_img): if j == end_ind: break im = dataset.pull_image(j) ims.append(im) image_ids.append(j) logger.data_toc() logger.infer_tic() result, features = rcnn_test.im_detect_bbox(model, ims) if cfg.MODEL.MASK_ON: result = rcnn_test.im_detect_mask(model, result, features) if cfg.MODEL.PARSING_ON: result = rcnn_test.im_detect_parsing(model, result, features) logger.infer_toc() logger.post_tic() eval_results, ims_results = post_processing( result, image_ids, dataset) box_results, seg_results, par_results, par_score = eval_results ims_dets, ims_labels, ims_segs, ims_pars = ims_results if cfg.VIS.ENABLED: for k, im in enumerate(ims): if len(ims_dets) == 0: break im_name = dataset.get_img_info(image_ids[k])['file_name'] vis_im = vis_utils.vis_one_image_opencv( im, cfg, ims_dets[k], ims_labels[k], segms=ims_segs[k], parsing=ims_pars[k], dataset=dataset, ) cv2.imwrite( os.path.join(cfg.CKPT, 'vis', '{}'.format(im_name)), vis_im) all_boxes += box_results all_segms += seg_results all_parss += par_results all_pscores += par_score logger.post_toc() logger.iter_toc() logger.log_stats(i, start_ind, end_ind, len(dataset)) return all_boxes, all_segms, all_parss, all_pscores
def _vis_single_frame(im, cls_boxes_i, cls_segms_i, cls_keyps_i, cls_tracks_i, thresh): res = vis_utils.vis_one_image_opencv( im, cls_boxes_i, segms=cls_segms_i, keypoints=cls_keyps_i, tracks=cls_tracks_i, thresh=thresh, show_box=True, show_class=False, linewidth=3) if res is None: return im return res
def vis(im_name, im, cls_boxes, cls_segms, cls_keyps): dummy_coco_dataset = dummy_datasets.get_coco_dataset() out_dir = None loaded = vis_utils.vis_one_image_opencv(im, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.9, kp_thresh=2, show_box=False, dataset=None, show_class=False) misc.imsave("loaded.png", loaded)
def test(model, dataset, start_ind, end_ind, all_hooks): total_num_images = len(dataset) all_boxes = [] num_img = cfg.TEST.IMS_PER_GPU with torch.no_grad(): for i in range(start_ind, end_ind, num_img): all_hooks.iter_tic() all_hooks.data_tic() ims = [] image_ids = [] for j in range(i, i + num_img): if j == end_ind: break ims.append(dataset.pull_image(j)) image_ids.append(j) all_hooks.data_toc() all_hooks.infer_tic() result, features = rcnn_test.im_detect_bbox(model, ims) if cfg.MODEL.OPLD_ON: result = rcnn_test.im_detect_opld(model, result, features) all_hooks.infer_toc() all_hooks.post_tic() eval_results, ims_results = post_processing( result, image_ids, dataset) box_results = eval_results ims_dets, ims_labels = ims_results if cfg.VIS.ENABLED: for k, im in enumerate(ims): if len(ims_dets) == 0: break im_name = dataset.get_img_info(image_ids[k])['file_name'] vis_im = vis_utils.vis_one_image_opencv( im, cfg.VIS, boxes=ims_dets[k], classes=ims_labels[k], dataset=dataset) cv2.imwrite( os.path.join(cfg.CKPT, 'vis', '{}'.format(im_name)), vis_im) all_boxes += box_results all_hooks.post_toc() all_hooks.iter_toc() all_hooks.log_stats(i, start_ind, end_ind, total_num_images) return all_boxes
def draw_on_image(self, image, boxes, segments, keypoints, threshold=THRESHOLD): if isinstance(image, str): image = cv2.imread(image) result = vis_utils.vis_one_image_opencv(im=image, boxes=boxes, keypoints=keypoints, segms=segments, thresh=threshold, dataset=self.__dataset, show_class=False, show_box=True) return result
def detectron_vizualize(config, frame: FrameType, cls_boxes: bytes, cls_segms: bytes, cls_keyps: bytes) -> FrameType: cls_boxes = pickle.loads(cls_boxes) cls_segms = pickle.loads(cls_segms) cls_keyps = pickle.loads(cls_keyps) vis_im = vis_utils.vis_one_image_opencv( frame[:, :, ::1], # BGR -> RGB for visualization cls_boxes, cls_segms, cls_keyps, dataset=dummy_datasets.get_coco_dataset(), show_class=True, thresh=0.7, kp_thresh=2) return vis_im
def draw_bbox_mask_pose(im, boxes, segms=None, keypoints=None, thresh=0.7, kp_thresh=2, show_box=False, dataset=None, show_class=False): vis_result = vis_utils.vis_one_image_opencv( im[:, :, ::-1], # BGR -> RGB for visualization boxes, segms=segms, keypoints=keypoints, thresh=thresh, kp_thresh=kp_thresh, show_box=show_box, dataset=dataset, show_class=show_class) return vis_result
def _vis_single_frame(im, cls_boxes_i, cls_segms_i, cls_keyps_i, cls_tracks_i, thresh, show_box=False, show_class=False, show_id=False, show_conf=False): """ input: :param im: input image as narray :param cls_boxes_i: a [N by 5] list containing bounding boxes detected in the image in the form of [x0, y0, x1, y1, conf] :param cls_segms_i: segments in the image :param cls_keyps_i: a [N by (4, 17)] keypoints detected in the image with the for of nparray[X,Y,scoreX,scoreY] :param cls_tracks_i: a list containing the track id for each bounding box :param thresh: floating number defining the threshold of confidence level for showing bounding boxes :param show_box: boolian parameter to decide showing bounding boxes :param show_class: boolian parameter to decide showing class type :param show_id: boolian parameter to decide showing track id :param show_conf: boolian parameter to decide showing confidence level :return: image with visualizations """ res = vis_utils.vis_one_image_opencv(im, cls_boxes_i, segms=cls_segms_i, keypoints=cls_keyps_i, tracks=cls_tracks_i, thresh=thresh, kp_thresh=2.3, show_box=show_box, show_class=show_class, show_id=show_id, show_conf=show_conf, linewidth=4) if res is None: return im return res
def main(): """main function""" if not torch.cuda.is_available(): sys.exit("Need a CUDA device to run the code.") args = parse_args() print('Called with args:') print(args) assert args.image_dir or args.images assert bool(args.image_dir) ^ bool(args.images) print('load cfg from file: {}'.format(args.cfg_file)) cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) assert bool(args.load_ckpt) ^ bool(args.load_detectron), \ 'Exactly one of --load_ckpt and --load_detectron should be specified.' cfg.MODEL.LOAD_IMAGENET_PRETRAINED_WEIGHTS = False # Don't need to load imagenet pretrained weights assert_and_infer_cfg() maskRCNN = Generalized_RCNN() if args.cuda: maskRCNN.cuda() if args.load_ckpt: load_name = args.load_ckpt print("loading checkpoint %s" % (load_name)) checkpoint = torch.load(load_name, map_location=lambda storage, loc: storage) net_utils.load_ckpt(maskRCNN, checkpoint['model']) if args.load_detectron: print("loading detectron weights %s" % args.load_detectron) load_detectron_weight(maskRCNN, args.load_detectron) maskRCNN = mynn.DataParallel(maskRCNN, cpu_keywords=['im_info', 'roidb'], minibatch=True, device_ids=[0]) # only support single GPU maskRCNN.eval() if args.image_dir: imglist = misc_utils.get_imagelist_from_dir(args.image_dir) else: imglist = args.images num_images = len(imglist) if not os.path.exists(args.output_dir): os.makedirs(args.output_dir) for i, im_name in enumerate(imglist): out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(im_name) + '.png')) print('Processing {} -> {}'.format(im_name, out_name)) im = cv2.imread(im_name) assert im is not None timers = defaultdict(Timer) cls_boxes, cls_segms, cls_keyps = im_detect_all(maskRCNN, im, timers=timers) im = vis_utils.vis_one_image_opencv(im, cls_boxes, cls_segms, cls_keyps, thresh=0.5, show_box=True, show_class=True) cv2.imwrite(out_name, im) if args.merge_pdfs and num_images > 1: merge_out_path = '{}/results.pdf'.format(args.output_dir) if os.path.exists(merge_out_path): os.remove(merge_out_path) command = "pdfunite {}/*.pdf {}".format(args.output_dir, merge_out_path) subprocess.call(command, shell=True)
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() model = infer_engine.initialize_model_from_cfg(args.weights) dummy_coco_dataset = dummy_datasets.get_coco_dataset() if os.path.isdir(args.video_name): print("video_name", args.video_name) else: print("video is not existing") cap = cv2.VideoCapture(args.video_name) while cap.isOpened(): ret, frame = cap.read() if not ret: break frame = cv2.resize(frame, dsize=(1280, 720)) timers = defaultdict(Timer) t1 = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t1)) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) frame = vis_utils.vis_one_image_opencv(frame, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.8, kp_thresh=2, show_box=True, dataset=dummy_coco_dataset, show_class=True) t2 = time.time() durr = float(t2 - t1) fps = 1.0 / durr cv2.putText(frame, "fps:%.3f" % fps, (20, 20), 4, 0.5, (0, 255, 0), 1, cv2.LINE_AA) cv2.imshow('Detection', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()
def predict_dataset(project, out_dir="/tmp/predictions/", visualize=False, visualize_dataset="ade", randomize=False): if visualize: vis_dir = os.path.join(out_dir, "vis") if visualize_dataset == "ade": dummy_dataset = dummy_datasets.get_ade_dataset() else: dummy_dataset = dummy_datasets.get_coco_dataset() config = projects.get_config(args.project) img_dir = config["images"] pkl_dir = os.path.join(out_dir, "pkl") im_list = [line.rstrip() for line in open(config["im_list"], 'r')] if args.randomize: # Shuffle image list random.seed(3) random.shuffle(im_list) for i, im_name in enumerate(im_list): img_path = os.path.join(img_dir, im_name) img_basename = os.path.splitext(im_name)[0] pkl_path = os.path.join(pkl_dir, img_basename + '.pkl') if os.path.exists(pkl_path): print("Already done") continue logger.info('Processing {} -> {}'.format(im_name, vis_path)) logger.info('{}/{}'.format(i, len(im_list))) # Predict im = cv2.imread(img_path) 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)') # Save prediction pickle pkl_obj = (cls_boxes, cls_segms, cls_keyps) if not os.path.isdir(os.path.dirname(pkl_path)): os.makedirs(os.path.dirname(pkl_path)) pickle.dump(pkl_obj, open(pkl_path, "wb")) if visualize: vis_path = os.path.join(vis_dir, img_basename + '.png') if not os.path.isdir(os.path.dirname(vis_path)): os.makedirs(os.path.dirname(vis_path)) vis_image = vis_utils.vis_one_image_opencv(im[:, :, ::-1], cls_boxes, cls_segms, cls_keyps, thresh=0, kp_thresh=2, dataset=dummy_dataset, show_box=True, show_class=True) cv2.imwrite(vis_path, vis_image)
vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization 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) im = vis_utils.vis_one_image_opencv(im, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, thresh=0.7, show_class=True) classxy = vis_utils.vis_one_image_opencv2(im, cls_boxes, cls_segms, cls_keyps, dataset=dummy_coco_dataset, thresh=0.7, show_class=True) if type(classxy[0][0]) == np.ndarray: pass else: #print ("***********************IMIM****IMIM")
def main(args): logger = logging.getLogger(__name__) merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 # get the weight path 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): # glob.iglob will generate a iterator that has same elements as that in glob.glob 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)') # save as pdf using matplotlib.pyplot proc_im = vis_utils.vis_one_image_opencv(im, cls_boxes, dataset=dummy_coco_dataset, thresh=0.7, show_box=True, show_class=True) cv2.imshow('img', proc_im) cv2.waitKey(0) """ 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.7, kp_thresh=2 ) """ cv2.destroyWindow('img')
def main(args): """A dummy COCO dataset that includes only the 'classes' field.""" dummy_coco_dataset = dummy_datasets.get_coco_dataset() ''''load initial Detectron config system''' cfg_orig = yaml.load(yaml.dump(cfg)) print("video is :",args.video_name) cap = cv2.VideoCapture(args.video_name) while cap.isOpened(): ret, frame = cap.read() if not ret: break t1 = time.time() frame = cv2.resize(frame,dsize=(1280,720)) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(frame, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps = None, None, None for i in range(0, len(args.models_to_run), 2): pkl = args.models_to_run[i] yml = args.models_to_run[i + 1] cfg.immutable(False) '''load initial global Detectron config system''' merge_cfg_from_cfg(cfg_orig) """Load a yaml config file and merge it into the global config.""" merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS '''Number of GPUs to use''' cfg.NUM_GPUS = 1 assert_and_infer_cfg() '''Initialize a model from the global cfg.''' model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): '''Inference detecting all''' cls_boxes_, cls_segms_, cls_keyps_ = model_engine.im_detect_all(model, frame, proposal_boxes) cls_boxes = cls_boxes_ if cls_boxes_ is not None else cls_boxes cls_segms = cls_segms_ if cls_segms_ is not None else cls_segms cls_keyps = cls_keyps_ if cls_keyps_ is not None else cls_keyps workspace.ResetWorkspace() """Constructs a numpy array with the detections visualized.""" frame = vis_utils.vis_one_image_opencv( frame, cls_boxes, segms=cls_segms, keypoints=cls_keyps, thresh=0.8, kp_thresh=2, show_box=True, dataset=dummy_coco_dataset, show_class=True) t2 = time.time() durr = float(t2-t1) fps = 1.0 / durr cv2.putText(frame,"fps:%.3f"%fps,(20,20),4, 0.5, (0, 255, 0), 1, cv2.LINE_AA) cv2.imshow('Detection', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()
def main(args): merge_cfg_from_file(args.cfg) cfg.NUM_GPUS = 1 # get the weight path 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() img_list = os.listdir(args.img_dir) img_list = sorted(img_list) print("image dir: %s" % args.img_dir) video_len = len(img_list) fps = 25 width = 640 height = 512 #video_file = args.video_file #print("video: %s" % video_file) #cap = cv2.VideoCapture(video_file) #video_len = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) #fps = int(cap.get(cv2.CAP_PROP_FPS)) #width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) #height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) terminate, is_paused = False, False idx = 0 # I have to compute fourcc in advance, because there will be error # Expected single character string for argument 'c1', I have't figure out how to solve it #fourcc = cv2.VideoWriter_fourcc(*"mp4v") # XVID: 1145656920 # mp4v: 1983148141 fourcc = 1983148141 #video_basename = os.path.basename(video_file) #video_name, video_ext = os.path.splitext(video_basename) #output_name = video_name + '_processed' + video_ext output_name = 'downtown_night_new.mp4' output_dir = args.output_dir if not os.path.exists(output_dir): os.makedirs(output_dir) output_file = os.path.join(output_dir, output_name) video_writer = cv2.VideoWriter(output_file, fourcc, fps, (width, height)) while not terminate: print("processing: %.4f%%" % ((idx + 1) * 100.0 / video_len)) #print("debug") if not is_paused: img_path = os.path.join(args.img_dir, img_list[idx]) frame = cv2.imread(img_path) idx += 1 with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, None) new_frame = vis_utils.vis_one_image_opencv(frame, cls_boxes, thresh=0.7, show_box=True) video_writer.write(new_frame) if idx == video_len: terminate = True """ cv2.imshow('image', new_frame) key = cv2.waitKey(1) if key & 255 == 27: # ESC print("terminating") terminate = True elif key & 255 == 32: # ' ' print("toggeling pause: " + str(not is_paused)) is_paused = not is_paused elif key & 255 == 115: # 's' print("stepping") ret, frame = cap.read() if not ret: break with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, frame, None, None ) is_paused = True """ video_writer.release()
im_name, args.output_dir, cls_boxes, cls_segms, ###############cls_segms###################### cls_keyps, dataset=dummy_coco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2 ) ''' vis_utils.vis_one_image_opencv( im[:, :, ::-1], cls_boxes, cls_segms, cls_keyps, thresh=0.7, kp_thresh=2, show_box=False, dataset=dummy_coco_dataset, show_class=True ) if __name__ == '__main__': workspace.GlobalInit(['caffe2', '--caffe2_log_level=0']) utils.logging.setup_logging(__name__) args = parse_args() main(args)