def run(input_file_in_memory, method): if input_file_in_memory.shape[2] == 4: input_file_in_memory = input_file_in_memory[:, :, 0:-1] if method == 'instancesegmentation' or method == 'predictions': config_file = '/workspace/detectron2_repo/configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml' elif method == 'panopticsegmentation': config_file = '/workspace/detectron2_repo/configs/quick_schedules/panoptic_fpn_R_50_inference_acc_test.yaml' elif method == 'keypoint': config_file = '/workspace/detectron2_repo/configs/quick_schedules/keypoint_rcnn_R_50_FPN_inference_acc_test.yaml' elif method == 'densepose': io_buf = None io_buf = io.BytesIO(apply_net_main(input_file_in_memory)) return io_buf else: return {'message': 'invalid parameter'} cfg = setup_cfg(config_file=config_file, is_gpu=False) debug = False if method == 'predictions' else True demo = VisualizationDemo(cfg, debug=debug) predictions, visualized_output, obj = demo.run_on_image( input_file_in_memory, debug) if debug: np_img = visualized_output.get_image() output_file_in_memory = cv2.cvtColor(np_img, cv2.COLOR_BGR2RGB) is_success, buffer = cv2.imencode(".jpg", output_file_in_memory) io_buf = io.BytesIO(buffer) return io_buf else: return obj
def rcnn(img): mp.set_start_method("spawn", force=True) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) img = np.flip(img, 2) start_time = time.time() predictions, visualized_output = demo.run_on_image(img) # print(predictions['instances'].pred_boxes.tensor) return predictions[ 'instances'].pred_boxes.tensor, visualized_output.get_image()
def cmd(i, o): mp.set_start_method("spawn", force=True) cfg = setup_cfg() demo = VisualizationDemo(cfg) img = read_image(i, format="BGR") inputimg_shape = cv2.imread(i).shape[:2] predictions, visualized_output = demo.run_on_image(img) visualized_output.save(o) #output prediction results to json import json prediction_dict = predictions['instances'].get_fields() classes = ['text', 'title', 'list', 'table', 'figure'] prediction_result = {} prediction_result['inputImgShape'] = inputimg_shape #make categories list categories = [] for i in prediction_dict['pred_classes'].tolist(): categories.append(classes[i]) #make overall ratio list overall_ratio = [] for i in prediction_dict['pred_boxes'].tensor.tolist(): small_box = [] for j in range(len(i)): if ((j == 0) or (j == 2)): small_box.append(i[j] / inputimg_shape[1]) elif ((j == 1) or (j == 3)): small_box.append(i[j] / inputimg_shape[0]) overall_ratio.append(small_box) detected_boxes_list = [] for i in range(len(prediction_dict['pred_boxes'])): detected_bos_and_category = {} detected_bos_and_category['category'] = categories[i] detected_bos_and_category['detectedBoxArea'] = prediction_dict[ 'pred_boxes'].tensor.tolist()[i] detected_bos_and_category['overallRatioOfDetectedBox'] = overall_ratio[ i] detected_bos_and_category['confidenceScore'] = prediction_dict[ 'scores'].tolist()[i] detected_boxes_list.append(detected_bos_and_category) prediction_result['detectedBoxes'] = detected_boxes_list f = open('prediction_result.json', 'w') json.dump(prediction_result, f) print('successed')
def get_result(event): """ docstring """ setup_logger(name="fvcore") logger = setup_logger() cfg = setup_cfg() demo = VisualizationDemo(cfg) from_s3_to_tmp(event) # use PIL, to be consistent with evaluation img = read_image('/tmp/input.jpg', format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) out_filename = '/tmp/output.jpg' visualized_output.save(out_filename)
def load_model(): args, unknown = get_parser().parse_known_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) model = VisualizationDemo(cfg) return model
def getModel(): mp.set_start_method("spawn", force=True) args = get_parser().parse_args() args.config_file = './config/LISA_101_FPN_3x_demo.yaml' logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) return demo
def main(): cfg = setup_config() realsense_cfg = setup_realsense() pipeline = rs.pipeline() pipeline.start(realsense_cfg) visualizer = VisualizationDemo(cfg) try: while True: frames = pipeline.wait_for_frames() color_frame = frames.get_color_frame() color_frame = np.asanyarray(color_frame.get_data()) frame = color_frame # Get depth frame align = rs.align(rs.stream.color) aligned_frames = align.process(frames) aligned_depth_frame = aligned_frames.get_depth_frame() #depth_frame = np.asanyarray(aligned_depth_frame.get_data()) # Do instance segmentation output, vis = visualizer.run_on_image(frame) print(output['instances'].pred_classes) # Calculate distance boxes = output['instances'].pred_boxes if len(boxes) != 0: dist_list = get_distance_list(boxes, aligned_depth_frame) for d in dist_list: #cv2.putText(vis, "dist = " + str(d), (50,50), # cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,0), 2, cv2.LINE_AA) print(str(dist_list)) cv2.imshow('mask', vis) cv2.waitKey(1) finally: # Stop streaming pipeline.stop()
def object_d2(files): # mp.set_start_method("spawn", force=True) args, unknown = get_parser().parse_known_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) for video_id in tqdm(files): try: # Load video with CV2 video = cv2.VideoCapture(f'{vid_folder}/{video_id}.mp4') print(f'Video name {"<"*10} {video_id}.mp4 >{">"*10} Loaded') width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) frames_per_second = video.get(cv2.CAP_PROP_FPS) img_pixels = height*width num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) print(f'Image height, width, frames_per_second, num_frames and img_pixels is {">"*10}{(height, width, num_frames,frames_per_second, img_pixels)}') if frames_per_second ==0: pass else: print(f'video.get(cv2.CAP_PROP_FRAME_COUNT) >> {video.get(cv2.CAP_PROP_FRAME_COUNT)}') duration = num_frames/frames_per_second print('Total frames are ',num_frames) frames=[] # list of predictions for each frame and object all_preds = list(demo.run_on_video(video)) # while num_frames!=0: # semantic_predictions = next(all_preds) # semantic_predictions = item for num_frame, semantic_predictions in enumerate(all_preds): objs = [] for s in semantic_predictions: obj = {} obj["label"] = s["text"] obj['area_percentage'] = float("{0:.2f}".format(s['area']/img_pixels*100)) obj["score"] = float("{0:.2f}".format(s["score"] if "score" in s else 1)) objs.append(obj) obj_set = {} for s in semantic_predictions: k = s["text"] score = s["score"] if "score" in s else 1 if not k in obj_set: obj_set[k] = { "scores": [score], "areas": [s["area"]], "label": k } else: obj_set[k]["scores"].append(score) obj_set[k]["areas"].append(s["area"]) u_objs = [] for k in obj_set: u = obj_set[k] n = len(u["scores"]) score_ave = reduce((lambda x, y: x + y), u["scores"])/n area_sum = reduce((lambda x, y: x + y), u["areas"]) obj = {} obj["label"] = u["label"] obj['area_percentage'] = float("{0:.2f}".format(area_sum/img_pixels*100)) obj["score"] = float("{0:.2f}".format(score_ave)) obj["count"] = n u_objs.append(obj) frame = { "frame":num_frame+1, "instances": objs, "objects": u_objs, } frames.append(frame) cv2.destroyAllWindows() data = { "video": { "meta": {}, "base_uri": "https://videobank.blob.core.windows.net/videobank", "folder": video_id, "output-frame-path": "" }, "ml-data": { "object-detection": { "meta": {'duration':duration, 'fps':frames_per_second,'len_frames':len(frames)}, "video": {}, "frames": frames } } } print(f'writing OD output inside {">"*10} {json_folder}/{video_id}.json') with open(f'{json_folder}/{video_id}.json', 'w') as f: json.dump(data,f) except Exception as e: print(f'Caught exception during inference, error is {">"*10} {e}') with open(f'{basepath}/err_vidsod.txt','a') as f: f.write(str(e)) pass
default=None, help="output images name", ) parser.add_argument( "--confidence-threshold", type=float, default=0.5, help="Minimum score for instance predictions to be shown", ) return parser if __name__ == "__main__": args = get_parser().parse_args() cfg = setup_cfg(args) input = args.input output = args.output debug = output is not None demo = VisualizationDemo(cfg, debug) # use PIL, to be consistent with evaluation img = read_image(input, format="BGR") predictions, visualized_output, obj = demo.run_on_image(img, debug) if output != None: visualized_output.save(output) print(output) else: print(json.dumps(obj))
default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) videos = [ "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33" ] output_dir = "/public/MOTDataset/HIE20/ResNeSt200_hie_all_detections_iou07/test" if not os.path.exists(output_dir): os.makedirs(output_dir) for v in videos: video_sub_dir = "/public/MOTDataset/HIE20/images/test/{}/img".format(v) imgs = get_all_imgs_in_dir(video_sub_dir) output_file = "{}/{}.txt".format(output_dir, v) results = [] for img in tqdm.tqdm(imgs):
cfg = setup_cfg(args) if args.video_input: video = cv2.VideoCapture(args.video_input) width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) basename = os.path.basename(args.video_input) output_folder_name = os.path.join("../output/", os.path.splitext(basename)[0]) os.makedirs(output_folder_name) if args.output: json_output_fname = os.path.join(args.output)[:-4] num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) demo = VisualizationDemo(cfg=cfg, parallel=args.parallel) window_size = 5 # make video with bbox and append instance information data_array = [] idx = 0 for frame_instances in tqdm.tqdm(demo.run_on_video(video), total=num_frames): idx += 1 data_array.append(frame_instances) video.release() num_frames = idx pose_refinement = PoseRefinement( width, height, num_frames, basename, window_size )
visualized_output.save(output_file) print("") if __name__ == "__main__": mp.set_start_method("spawn", force=True) args_list = [ "configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml", "chair1.jpg", 0.6, [ "MODEL.WEIGHTS", "detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x/137849600/model_final_f10217.pkl" ], "chair1_masked.jpg" ] cfg = setup_cfg(args_list) demo = VisualizationDemo(cfg) # use PIL, to be consistent with evaluation img = read_image(args_list[1], format="BGR") predictions, visualized_output = demo.run_on_image(img) # 계산한 prediction에서 mask를 가져옴. masks = predictions['instances'].get_fields()["pred_masks"] masks = masks.tolist() (height, width) = predictions['instances'].image_size instance_number = len(predictions['instances']) for i in range(0, instance_number): get_only_instance_image(args_list[FILE_NAME], masks[i], height, width)
with open(os.path.join(path, filename) + '.csv', 'w', newline='') as csvfile: writer = csv.writer(csvfile) writer.writerows(table) if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"])) if "instances" in predictions else "finished", time.time() - start_time,
help="Modify model config options using the command-line", default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) folder_images = os.path.expanduser(args.input_folder) images = [] images = glob.glob(os.path.join(folder_images, "*.png")) images.extend(glob.glob(os.path.join(folder_images, "*.jpg"))) images.extend(glob.glob(os.path.join(folder_images, "*.jpeg"))) for path in tqdm.tqdm(images): img = read_image(path, format="BGR") img_name = os.path.splitext( os.path.basename(path))[0] # without file suffix start_time = time.time() valid_classes = [ "bicycle", "person", "car", "truck", "bus", "motorbike"
default=[], ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) test_metadata = MetadataCatalog.get("my_dataset_test") demo = VisualizationDemo(cfg, metadata=test_metadata) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"])) if "instances" in predictions else "finished", time.time() - start_time, ))
help="Modify config options using the command-line 'KEY VALUE' pairs", default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) # if args.input: # # if os.path.isdir(args.input[0]): # # args.input = [os.path.join(args.input[0], fname) for fname in os.listdir(args.input[0])] # # elif len(args.input) == 1: # # args.input = glob.glob(os.path.expanduser(args.input[0])) # # assert args.input, "The input path(s) was not found" # # # for path in tqdm.tqdm(args.input, disable=not args.output): # # # use PIL, to be consistent with evaluation # # import pdb;pdb.set_trace() # print(args.input[0]) # for folder in os.listdir(args.input[0]): # for img_path in os.listdir(args.input[0]+'/'+folder): # if img_path.endswith('.jpg'): # path = args.input[0]+'/'+folder + '/'+ img_path
def create_annotation(image_folder, json_path, confidence_thresh=0.8): json_dict = { "images": [], "type": "instances", "annotations": [], "categories": [] } mp.set_start_method("spawn", force=True) args = get_parser().parse_args() logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) image_path = {} for path, subdirs, files in os.walk(image_folder): for name in files: print(name) if name.endswith('.jpg') or \ name.endswith('.png') or \ name.endswith('.JPG') or \ name.endswith('.PNG') or \ name.endswith('.jpeg') or \ name.endswith('.JPEG'): image_path[name] = os.path.join(path, name) print("length: ", len(image_path.keys())) for path in tqdm.tqdm(image_path.keys(), disable=not args.output): # use PIL, to be consistent with evaluation start_time = time.time() try: img = read_image(image_path[path], format="BGR") # run detector predictions, visualized_output, shape = demo.run_on_image(img) except: print("except") continue height, width, channel = shape global count ## append image info image = { "file_name": str(path), "height": str(height), "width": str(width), "id": str(count), } count += 1 # if count > 10: # break json_dict["images"].append(image) ## append annotation info bnd_id = 0 for i in range(len(predictions["instances"].pred_boxes)): if predictions["instances"].scores[ i] > confidence_thresh and predictions[ "instances"].pred_classes[i] in [0, 2, 5, 7]: # print(predictions["instances"].pred_boxes[i].tensor) x_center, y_center, o_width, o_height = predictions[ "instances"].pred_boxes[i].tensor[0].cpu().detach().numpy( ) score = predictions["instances"].scores[i].cpu().detach( ).numpy() pred_class = predictions["instances"].pred_classes[i].cpu( ).detach().numpy() # print(x_center, y_center, o_width, o_height, score) ann = { "area": str(o_width * o_height), "iscrowd": 0, "image_id": str(count), "bbox": [ str(int(x_center - o_width / 2)), str(int(y_center - o_height / 2)), str(o_width), str(o_height) ], "category_id": str(pred_class + 1), "id": str(bnd_id), "ignore": 0, "segmentation": [], } bnd_id += 1 json_dict["annotations"].append(ann) # cat = {"supercategory": "none", "id": cid, "name": cate} # json_dict["categories"].append(cat) # if args.output: # if os.path.isdir(args.output): # assert os.path.isdir(args.output), args.output # out_filename = os.path.join(args.output, os.path.basename(path)) # else: # assert len(args.input) == 1, "Please specify a directory with args.output" # out_filename = args.output # visualized_output.save(out_filename) # print("pred_boxes: ", predictions["instances"].pred_boxes) # print("scores: ", predictions["instances"].scores) # print("pred_classes: ", predictions["instances"].pred_classes) # print("shape: ", width, height, channel) # logger.info( # "{}: detected {} instances in {:.2f}s".format( # path, len(predictions["instances"]), time.time() - start_time # ) # ) logger.info( ("progress: {:.0f} / {:.0f}".format(count, len(image_path.keys())))) ## append category info cat = {"supercategory": "none", "id": str(1), "name": "person"} json_dict["categories"].append(cat) cat = {"supercategory": "none", "id": str(3), "name": "car"} json_dict["categories"].append(cat) cat = {"supercategory": "none", "id": str(6), "name": "bus"} json_dict["categories"].append(cat) cat = {"supercategory": "none", "id": str(8), "name": "truck"} json_dict["categories"].append(cat) os.makedirs(os.path.dirname(json_path), exist_ok=True) json_fp = open(json_path, "w") json_str = json.dumps(json_dict) json_fp.write(json_str) json_fp.close()
nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) # demo = VisualizationDemo(cfg) demo = VisualizationDemo(cfg, instance_mode=ColorMode.IMAGE_BW) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"])) if "instances" in predictions else "finished", time.time() - start_time,
default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg, parallel=True) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"])) if "instances" in predictions else "finished", time.time() - start_time,
if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg_object, cfg_keypoint = setup_cfg(args) database_json = {} database_json['annotation'] = {} database_arr = [] if args.mlp: demo = VisualizationDemoMLP(cfg_object, cfg_keypoint) else: demo = VisualizationDemo(cfg_object, cfg_keypoint) frame = 0 if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: detected {} instances in {:.2f}s".format( path, len(predictions["instances"]), time.time() - start_time))
default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg, instance_mode=ColorMode.IMAGE, parallel=False) if args.video_input: video = cv2.VideoCapture(args.video_input) width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) frames_per_second = video.get(cv2.CAP_PROP_FPS) num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) basename = os.path.basename(args.video_input) if args.output: if os.path.isdir(args.output): output_fname = os.path.join(args.output, basename) output_fname = os.path.splitext(output_fname)[0] + ".mkv" else:
'detection_classes': predictions.pred_classes.numpy(), 'detection_score': predictions.scores.numpy() } all_detection_outputs[frame_num] = output_dict vis_frame = video_visualiser.draw_instance_predictions( frame[:, :, ::-1], predictions) cv2.imwrite(visualised_jpg_path, vis_frame.get_image()[:, :, ::-1]) with open(predictions_save_path, 'wb') as handle: pickle.dump(all_detection_outputs, handle, protocol=pickle.HIGHEST_PROTOCOL) elif args.video_input: demo = VisualizationDemo(cfg) video = cv2.VideoCapture(args.video_input) width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) frames_per_second = video.get(cv2.CAP_PROP_FPS) num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) basename = os.path.basename(args.video_input) if args.output: if os.path.isdir(args.output): output_fname = os.path.join(args.output, basename) output_fname = os.path.splitext(output_fname)[0] + ".mkv" else: output_fname = args.output assert not os.path.isfile(output_fname), output_fname
default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation # img = read_image(path, format="BGR") img = read_image(path, format="RGB") # OneNet uses RGB input as default start_time = time.time() predictions, visualized_output = demo.run_on_image( img, args.confidence_threshold) logger.info("{}: {} in {:.2f}s".format( path,
# help='huaweiyun', # ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) basename = os.path.basename(args.video_input) video_input_name = basename.split('/')[-1:][0] demo = VisualizationDemo( cfg, "input/tracks_" + video_input_name.split('.')[0] + ".txt") if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() predictions, visualized_output = demo.run_on_image(img) logger.info("{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"])) if "instances" in predictions else "finished", time.time() - start_time,
xmin = str(int(boxes[i][0])) ymin = str(int(boxes[i][1])) xmax = str(int(boxes[i][2])) ymax = str(int(boxes[i][3])) file.writelines(xmin + ',' + ymin + ',' + xmax + ',' + ymax + ',') file.writelines('\r\n') file.close() if __name__ == "__main__": args = get_parser().parse_args() cfg = setup_cfg(args) detection_demo = VisualizationDemo(cfg) test_images_path = args.input output_path = args.output start_time_all = time.time() img_count = 0 for i in glob.glob(test_images_path): print(i) img_name = os.path.basename(i) img_save_path = output_path + img_name.split('.')[0] + '.jpg' img = cv2.imread(i) start_time = time.time() prediction, vis_output, polygons = detection_demo.run_on_image(img)
import tqdm import time from detectron2.config import get_cfg from detectron2.data.detection_utils import read_image from detectron2.utils.logger import setup_logger from predictor import VisualizationDemo # constants WINDOW_NAME = "COCO detections" if __name__ == "__main__": init_start = time.time() demo = VisualizationDemo() init_end = time.time() print("init time %.4f" % (init_end - init_start)) dir_name = "/media/gm/Data/SLAM/dataset/TUM/rgbd_dataset_freiburg3_sitting_halfsphere/rgb" file_name = os.listdir(dir_name) process_start = time.time() file_num = 0 for name in file_name: result = demo.run_on_image(os.path.join(dir_name, name), "result.png") file_num += 1 if file_num >= 10: break process_end = time.time() average_time = (process_end - process_start) / file_num print("average time %.4f" % average_time)
"If not given, will show output in an OpenCV window.", ) parser.add_argument( "--confidence-threshold", type=float, default=0.5, help="Minimum score for instance predictions to be shown", ) parser.add_argument( "--opts", help="Modify config options using the command-line 'KEY VALUE' pairs", default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg) listener(demo)
video.release() output_file.release() if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() logger = setup_logger() logger.info("Arguments: " + str(args)) if len(args.video_ids) == 0 and len(args.action_id) > 0: # load list of videos for specified action category video_list = get_list_of_videos(args.action_id) else: video_list = args.video_ids # setup configuration cfg = setup_cfg(args) # load model checkpoint demo = VisualizationDemo(cfg, save_preds=True) if args.run_as_frames: # run on images process_video_as_frames(demo, video_list) else: # run on videos process_videos(demo, video_list)
default=[], nargs=argparse.REMAINDER, ) return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) demo = VisualizationDemo(cfg, parallel=args.parallel) metadata = MetadataCatalog.get( cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else "__unused") class_names = metadata.thing_classes class_ids = [] for class_id, class_name in enumerate(class_names): class_ids.append(str(class_id)) class_data = np.c_[class_ids, class_names] assert os.path.isfile( args.video_input), "Please specify a video file with --video-input" if args.video_input: video = cv2.VideoCapture(args.video_input) width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)) frames_per_second = video.get(cv2.CAP_PROP_FPS) num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
return parser if __name__ == "__main__": mp.set_start_method("spawn", force=True) args = get_parser().parse_args() setup_logger(name="fvcore") logger = setup_logger() logger.info("Arguments: " + str(args)) cfg = setup_cfg(args) if args.save_raw_maps: assert args.output, "To save raw map(s), need to specify the 'output' parameter." demo = VisualizationDemo(cfg) if not args.save_raw_maps else MapsGetter(cfg) if args.input: if len(args.input) == 1: args.input = glob.glob(os.path.expanduser(args.input[0])) assert args.input, "The input path(s) was not found" for path in tqdm.tqdm(args.input, disable=not args.output): # use PIL, to be consistent with evaluation img = read_image(path, format="BGR") start_time = time.time() if not args.save_raw_maps: predictions, visualized_output = demo.run_on_image(img) logger.info( "{}: {} in {:.2f}s".format( path, "detected {} instances".format(len(predictions["instances"]))