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"]))
