def __getitem__(self, idx): im_name = 'DensePoseData/demo_data/xyz.jpg' output_dir = 'DensePoseData/' img_name1 = os.path.join(self.root_dir1, self.landmarks_frame.iloc[idx, 0]) image1 = cv2.imread(img_name1) img_name2 = os.path.join(self.root_dir2, self.landmarks_frame.iloc[idx, 1]) image2 = cv2.imread(img_name2) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( self.model, image1, None, timers=self.timers) im1 = vis_utils.vis_one_image( image1[:, :, ::-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) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( self.model, image2, None, timers=self.timers) im2 = vis_utils.vis_one_image( image2[:, :, ::-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) image3 = cv2.merge((image1, im1, im2)) sample = {'image1': image1, 'image2': image2, 'image3': image3} if self.transform: sample = self.transform(sample) return sample
def _process(self, im): t = time.time() cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, im, None, timers=self.timers) self.logger.info('Inference time: {:.3f}s'.format(time.time() - t)) for k, v in self.timers.items(): self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) self.logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') mask_list = vis_utils.vis_one_image_opencv_mask_list( im[:, :, ::-1], # BGR -> RGB for visualization #im_name, #args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=None, #box_alpha=0.3, show_class=True, thresh=self.args["thresh"], kp_thresh=self.args["kp_thresh"], #ext=args.output_ext, #out_when_no_box=args.out_when_no_box ) return np.array(mask_list)
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() model = infer_engine.initialize_model_from_cfg(args.weights) dummy_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): logger.info('Processing {}'.format(im_name)) im = cv2.imread(im_name) timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_scores, _, _ = infer_engine.im_detect_all(model, im, None, timers=timers) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) cl = np.argmax(cls_scores) for k, v in timers.items(): logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) logger.info(' | Class is: {}'.format(dummy_dataset.classes[cl])) logger.info(' | Class Confidance is: {:.2f}%'.format( cls_scores[cl] * 100)) 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 hanle_frame(args, frameId, im, logger, model, dataset): #out_name = os.path.join( # args.output_dir, '{}'.format(frameId + '.pdf') #) logger.info('Processing frame: {}'.format(frameId)) 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 frameId == 1: 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 '{}'.format(frameId), args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=2)
def run_model_cfg(args, im, check_blobs): workspace.ResetWorkspace() model, _ = load_model(args) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = test_engine.im_detect_all( model, im, None, None, ) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) # sort the results based on score for comparision boxes, segms, keypoints, classes = _sort_results( boxes, segms, keypoints, classes) # write final results back to workspace def _ornone(res): return np.array(res) if res is not None else np.array([], dtype=np.float32) with c2_utils.NamedCudaScope(0): workspace.FeedBlob(core.ScopedName('result_boxes'), _ornone(boxes)) workspace.FeedBlob(core.ScopedName('result_segms'), _ornone(segms)) workspace.FeedBlob(core.ScopedName('result_keypoints'), _ornone(keypoints)) workspace.FeedBlob(core.ScopedName('result_classids'), _ornone(classes)) # get result blobs with c2_utils.NamedCudaScope(0): ret = _get_result_blobs(check_blobs) return ret
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 infer(self, im, thresh=0.5): ts = time.time() timers = defaultdict(Timer) with c2_utils.NamedCudaScope(self.gpu_id): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.__model, im, None, timers=timers) te = time.time() print('det time:', te - ts) for k, v in timers.items(): print(' | {}: {:.3f}s'.format(k, v.average_time)) if isinstance(cls_boxes, list): boxes, segms, keypoints, classes = cvt_cls(cls_boxes, cls_segms, cls_keyps) if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh: return None heads = list() for i in range(len(boxes)): bbox = boxes[i, :4] score = boxes[i, -1] if score < thresh: continue heads.append([int(x) for x in bbox] + [float(score)]) return heads
def process_image(input_image, num_of_people, num_of_permutations): timers = defaultdict(Timer) t = time.time() image = stringToImage(input_image[input_image.find(",")+1:]) img = toRGB(image) size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers ) t2 = time.time() #logger.info('Inference time: {:.3f}s'.format(t2 - t)) jpgs = [] if cls_bodys is not None: (finals,num_people) = process_bodies(img, cls_boxes, cls_bodys, num_of_people, num_of_permutations) logger.info('Num of people {}'.format(num_people)) if len(finals) > 0: for final in finals: retval, buffer = cv2.imencode('.jpg', final) jpg_as_text = base64.b64encode(buffer) jpgs.append(jpg_as_text) else: print('Skipping') else: print('Skipping') return jpgs
def main(input_img): image = stringToImage(input_img[input_img.find(",") + 1:]) img = toRGB(image) logger.info('Processing {} -> {}'.format('New Image', 'Output...')) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] #img = imresize(img, (320, 240), interp='bilinear') with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) for key, timer in timers.items(): print(key, timer.total_time) t2 = time.time() densepose_img = vis_one_image(img, 'testImage', 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) logger.info('Inference time: {:.3f}s'.format(t2 - t)) return densepose_img
def getKptByModel(self, image, thresh=0.7): top_labels = [] top_xmin = [] top_ymin = [] top_xmax = [] top_ymax = [] top_scores = [] timers = defaultdict(Timer) # with c2_utils.NamedCudaScope(0): # cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( # self.model, image, None, timers=timers # ) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, image, None, timers=timers) # boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps) image = vis_utils.vis_one_image_opencv(image, cls_boxes, cls_segms, cls_keyps, dataset=None, show_class=True, thresh=0.7, kp_thresh=2) # try: # print (keypoints) # except: # pass return image
def detect(self, frame): timers = defaultdict(Timer) mask_frame = frame with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, mask_frame, None, timers=timers) # verifica se a imagem deve ser descartada boxes, sgms, keypts, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps) bbox_list = [] if len(boxes) > 0: indexes_big = box_utils.filter_big_boxes(boxes, 300) indexes_small = box_utils.filter_small_boxes(boxes, 100) for i in range(len(boxes)): if (i in indexes_big and i in indexes_small): if classes[i] in [1, 2, 3] and boxes[i, 4] > 0.7: box = boxes[i] bbox_list.append([ int(box[0]), int(box[1]), int(box[2]) - int(box[0]), int(box[3]) - int(box[1]) ], classes[i]) # mask_frame = vis_utils.vis_one_image_opencv(mask_frame, cls_boxes, cls_segms, cls_keyps, thresh=0.8, kp_thresh=2, # show_box=True, dataset=CocoNames, show_class=True) #, hiden_indexes=True, indexes_shown=[1]) return bbox_list
def main(args): logger = logging.getLogger(__name__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, args) workspace.ResetWorkspace() else: proposal_boxes = None cls_boxes, cls_segms, cls_keyps, cls_bodys = None, 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) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ , cls_bodys_= \ model_engine.im_detect_all(model, im, 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 cls_bodys = cls_bodys_ if cls_bodys_ is not None else cls_bodys workspace.ResetWorkspace() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf')) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) with open('test_vis.pkl', 'w') as f: pickle.dump( { 'im': im, 'cls_boxes': np.array(cls_boxes), 'cls_bodys': np.array(cls_bodys) }, f) vis_utils.vis_one_image(im[:, :, ::-1], args.im_file, 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)
def extract_iuv(image_path, model, infer_engine): im = cv2.imread(image_path) dummy_coco_dataset = dummy_datasets.get_coco_dataset() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, im, None ) iuv_out = vis_utils.vis_one_image( im[:, :, ::-1], # BGR -> RGB for visualization None, None, 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 ) return iuv_out
def single_process(args, dummy_coco_dataset, im, im_name, model): 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)' # ) print("预测结果:", cls_boxes, cls_segms, cls_keyps) new_img = 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) return new_img
def process_images( args_weights, args_im_or_folder, args_image_ext ): 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): 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 classes is not None: class_strs = [dummy_coco_dataset.classes[c] for c in classes] im_name = im_name.split('/')[-1].split('.'+args_image_ext)[0] yield im_name, boxes, segms, class_strs, im.shape[:2]
def process_image(input_file, output_file): #image = stringToImage(input_img[input_img.find(",")+1:]) #img = cv2.imread('stylegan/narrow/13.test.jpg') #img = cv2.imread('stylegan/curated/231.jpg') img = cv2.imread(input_file) #img = toRGB(image) #logger.info(input_file) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) t2 = time.time() #logger.info('Inference time: {:.3f}s'.format(t2 - t)) if cls_bodys is not None: (final, num_people) = process_bodies(img, cls_boxes, cls_bodys) if final is not None: if num_people > 4: output_file = output_file + 'X.jpg' else: output_file = output_file + '.jpg' cv2.imwrite(output_file, final) return True else: #print('Skipping') return False else: #print('Skipping') return False
def extract_person(image, background_image, model, dataset): timers = defaultdict(Timer) t = time.time() with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, image, None, timers=timers) boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format( cls_boxes, cls_segms, cls_keyps, ) masks = mask_util.decode(segms) masks = np.moveaxis(masks, 2, 0) output_image = np.copy(background_image) for box, mask, c, in zip(boxes, masks, classes): score = box[-1] if score < 0.9: continue if dataset.classes[c] != 'person': continue idx = np.where(mask != 0) output_image[idx[0], idx[1], :] = image[idx[0], idx[1], :] return output_image
def get_detections(self, image): cls_boxes, cls_depths, cls_segms, cls_keyps = infer_engine.im_detect_all( self.model, image, None) boxes, depths, _segms, _keyps, classes = convert_from_cls_format( cls_boxes, cls_depths, None, None) detections = [] for i in range(len(classes)): detection = {} detection["bbox"] = boxes[i, :4] detection["score"] = boxes[i, -1] detection["depth"] = depths[i] detection["category_id"] = classes[i] if detection["score"] > self.cla_thresholds[self.classnames[ detection["category_id"]]]: detections.append(detection) if self.filter_detections: filter_inside_boxes(detections, inside_ratio_thresh=self.inside_box_ratio) return detections
def main(input_img, with_pix2pix=False): image = stringToImage(input_img[input_img.find(",") + 1:]) img = toRGB(image) logger.info('Processing {} -> {}'.format('New Image', 'Output...')) timers = defaultdict(Timer) t = time.time() size = img.shape[:2] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( model, img, None, timers=timers) for key, timer in timers.items(): print(key, timer.total_time) t2 = time.time() r = vis_one_image(img, 'testImage', 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) t3 = time.time() if with_pix2pix: r = requests.post(pix2pixURL, data={'data': r}) logger.info('Inference time: {:.3f}s'.format(t2 - t)) logger.info('Visualization time: {:.3f}s'.format(t3 - t2)) logger.info('Pix2pix time: {:.3f}s'.format(time.time() - t3)) return r
def find_optimal_bars(image_directory, layer): model = get_model() im_list = glob.iglob(image_directory + '/*.jpg') im_list = [x for x in im_list] # so we can get length max_sd_per_map = [None] * len(im_list) for i, im_name in enumerate(im_list): print('processing {}'.format(im_name)) im = cv2.imread(im_name) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=None) responses = workspace.blobs['gpu_0/{}'.format(layer)] sd = [] for i in range(responses.shape[0]): sd.append(np.std(responses[i, :, :, :])) max_sd_across_boxes = responses[np.argmax(sd), :, :, :] # stimuli aren't processed in order, so get index from file name bar_name = os.path.basename(im_name)[3:-4] bar_num = int(bar_name) max_sd_per_map[bar_num] = np.max(np.max(max_sd_across_boxes, axis=-1), axis=-1) max_sd_per_map = np.array(max_sd_per_map) result = np.argmax(max_sd_per_map, axis=0) print result # TODO: check this return result
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 infer_image(self, image): #print(len(image)) if isinstance(image, str): image = cv2.imread(image) with c2_utils.NamedCudaScope(0): boxes, segments, _ = infer_engine.im_detect_all(self.__model, image, None) return boxes, segments
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 = 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__) dummy_nucoco_dataset = dummy_datasets.get_nucoco_dataset() cfg_orig = load_cfg(envu.yaml_dump(cfg)) ## Load image coco = COCO_PLUS(args.ann_file, args.imgs_dir) image_id = coco.dataset['images'][args.im_ind]['id'] img_path = os.path.join(args.imgs_dir, coco.imgs[image_id]["file_name"]) im = cv2.imread(img_path) ## Get the proposals for this image proposals = rrpn_loader(args.rpn_pkl) proposal_boxes = proposals[image_id]['boxes'] _proposal_scores = proposals[image_id]['scores'] workspace.ResetWorkspace() ## run models 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) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, 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() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(img_path) + '.pdf') ) logger.info('Processing {} -> {}'.format(img_path, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], img_path, args.output_dir, cls_boxes, cls_segms, cls_keyps, dataset=dummy_nucoco_dataset, box_alpha=0.3, show_class=True, thresh=0.7, kp_thresh=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() 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 hanle_frame(args, frameId, origin_im, im, logger, model, dataset, file_name): global predict_time, process_time, show_img logger.info('Processing frame: {}'.format(frameId)) # cv2.imshow("tmplog", im) # cv2.waitKey(0) timers = defaultdict(Timer) t = time.time() im = im[:, :, ::-1] with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all( model, im, None, timers=timers) predict_time.append(time.time() - t) logger.info('Inference time: {:.3f}s'.format(time.time() - t)) logger.info('predict_time: {:.3f}s'.format(np.mean( np.array(predict_time)))) # for k, v in timers.items(): # logger.info(' | {}: {:.3f}s'.format(k, v.average_time)) if frameId == 1: logger.info( ' \ Note: inference on the first image will be slower than the ' 'rest (caches and auto-tuning need to warm up)') t = time.time() img_debug = True ret = extractor.get_detection_line(im, cls_boxes, cls_segms, cls_keyps, dataset=dataset, show_class=True, thresh=0.8, kp_thresh=2, frame_id=frameId, img_debug=img_debug) im, mid_im, top_im, result, fork_pos = ret process_time.append(time.time() - t) logger.info('get_detection_line time: {:.3f}s'.format(time.time() - t)) # logger.info('process_time: {:.3f}s'.format(np.mean( np.array(process_time)))) line_list = None cache_list = None particles = None filter_list = None if not result is None: line_list, cache_list, filter_list, particles = add2MsgQueue( result, frameId, fork_pos, img_debug) g_debug_img_queue.put( (origin_im[:, :, ::-1], im, mid_im, top_im, line_list, cache_list, filter_list, frameId, fork_pos, file_name)) if g_debug_img_queue.full(): try: g_debug_img_queue.get_nowait() except Empty: print("Queue.Empty")
def get_iuv(self, img): timers = defaultdict(Timer) with c2_utils.NamedCudaScope(0): cls_boxes, cls_segms, cls_keyps, cls_bodys = infer_engine.im_detect_all( self.model, img, None, timers=timers) iuv = self.make_iuv(img, cls_boxes, cls_segms, cls_keyps, cls_bodys) if iuv is None: raise Exception("Nothing found") return iuv
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 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 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__) dummy_coco_dataset = dummy_datasets.get_coco_dataset() cfg_orig = load_cfg(yaml.dump(cfg)) im = cv2.imread(args.im_file) if args.rpn_pkl is not None: proposal_boxes, _proposal_scores = get_rpn_box_proposals(im, 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) merge_cfg_from_cfg(cfg_orig) merge_cfg_from_file(yml) if len(pkl) > 0: weights_file = pkl else: weights_file = cfg.TEST.WEIGHTS cfg.NUM_GPUS = 1 assert_and_infer_cfg(cache_urls=False) model = model_engine.initialize_model_from_cfg(weights_file) with c2_utils.NamedCudaScope(0): cls_boxes_, cls_segms_, cls_keyps_ = \ model_engine.im_detect_all(model, im, 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() out_name = os.path.join( args.output_dir, '{}'.format(os.path.basename(args.im_file) + '.pdf') ) logger.info('Processing {} -> {}'.format(args.im_file, out_name)) vis_utils.vis_one_image( im[:, :, ::-1], args.im_file, 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 )
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)