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,
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
def main_predict():
try:
mp.set_start_method("spawn", force=True)
# args = get_parser().parse_args()
args, unknown = get_parser().parse_known_args()
setup_logger(name="fvcore")
logger = setup_logger()
logger.info("Arguments: " + str(args))
cfg = setup_cfg(args)
print("A ...................")
demo = VisualizationDemo(cfg)
print("B ...................")
st = time.time()
if args.video_input:
# assert os.path.isfile(args.video_input)
# vid_path = args.video_input
# vid_name = vid_path.split('.mp4')[0]
# stream = ffmpeg.input(vid_path)
# stream = ffmpeg.filter(stream, 'fps', fps=args.fps, round='up')
# stream = ffmpeg.output(stream, f'{vid_name}_resized.mp4')
# ffmpeg.run(stream)
# video = cv2.VideoCapture(f'{vid_name}_resized.mp4')
# print("A")
# message = request.get_json(force=True)
# print("B")
# encoded = message['image']
# print("C")
# decoded = base64.b64decode(encoded)
# print("D")
# video_decoded = np.asarray(bytearray(decoded), dtype="uint8")
# print(f"decoded and shape is >>>>>>>>>> {video_decoded.shape}")
# video = cv2.VideoCapture(video_decoded)
print("E>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
# video = cv2.VideoCapture('/data/work/colab_d2_copy/colab_d2/docker_files/detectron2/demo/new_clip_resized.mp4')
video = cv2.VideoCapture(
'/app/docker_files/detectron2/demo/new_clip_resized.mp4')
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))
print(
f'<<<<<<<<<<<<<<<<<<<<< {video.get(cv2.CAP_PROP_FRAME_COUNT)}')
basename = os.path.basename(args.video_input)
#######################
duration = num_frames / frames_per_second
print(f'num_frames is {num_frames}')
print(f'duration is {duration} and fps is {frames_per_second}')
counter = 0
frames = []
all_preds = demo.run_on_video(video)
i = 1
while i <= num_frames:
semantic_predictions = next(all_preds)
# semantic_predictions = item
objs = []
for s in semantic_predictions:
obj = {}
obj["label"] = s["text"]
obj['area_percentage'] = float("{0:.2f}".format(s['area'] /
1000000))
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 /
1000000))
obj["score"] = float("{0:.2f}".format(score_ave))
obj["count"] = n
u_objs.append(obj)
frame = {
"frame": i,
"instances": objs,
"objects": u_objs,
}
print(f'num_frame is {i}')
counter += 1
i += 1
frames.append(frame)
cv2.destroyAllWindows()
data = {
"video": {
"meta": {},
"base_uri":
"https://videobank.blob.core.windows.net/videobank",
"folder": args.video_input,
"output-frame-path": "pipeline/detectron2"
},
"ml-data": {
"object-detection": {
"meta": {
'duration': duration,
'fps': frames_per_second,
'len_frames': len(frames)
},
"video": {},
"frames": frames
}
}
}
# print(f'data is {data}')
return jsonify(data)
except Exception as e:
print(f"error is >>>>>>>> {e}")
return "Wrong input format"
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,
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)
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
)
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)
# 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,
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, ColorMode.SEGMENTATION)
if args.input:
images = [
os.path.join(args.input, im) for im in os.listdir(args.input)
]
for im in tqdm.tqdm(images, disable=not args.output):
# use PIL, to be consistent with evaluation
name = os.path.basename(im)
img = read_image(im, format="BGR")
start_time = time.time()
predictions, visualized_output = demo.run_on_image(img)
if args.output:
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:
def get_obj_shadow_masks_predictor(config_file, confidence_threshold=0.5):
cfg = setup_cfg(config_file, confidence_threshold)
predictor = VisualizationDemo(cfg)
return predictor
cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold
cfg.freeze()
return cfg
if __name__ == "__main__":
mp.set_start_method("spawn", force=True)
args = get_parser().parse_args()
print(args)
setup_logger(name="fvcore")
logger = setup_logger()
logger.info("Arguments: " + str(args))
cfg = setup_cfg(args)
demo = VisualizationDemo(cfg, instance_mode=COLOR_MODE)
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,
)
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)
# 注册数据集
register_dataset()
demo = VisualizationDemo(cfg, instance_mode=ColorMode.SEGMENTATION)
# for path in tqdm.tqdm(args.input, disable=not args.output):
for imgfile in os.listdir(INPUT_IMG_PATH):
# use PIL, to be consistent with evaluation
img_fullName = os.path.join(INPUT_IMG_PATH, imgfile)
img = read_image(img_fullName, format="BGR")
start_time = time.time()
predictions, visualized_output = demo.run_on_image(img)
logger.info(
"{}: detected {} instances in {:.2f}s".format(
imgfile, len(predictions["instances"]), time.time() - start_time
)
)
"--output",
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))
'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
if os.path.isfile(filename):
return True
return False
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)
meta_data = calc_metadata(args)
demo = VisualizationDemo(cfg, meta_data)
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
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"]))
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)
ppl = 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 = ppl.run_on_image(img)
num_instances = len(predictions["instances"])
if num_instances > 0:
classes = predictions["instances"].pred_classes
labels = _create_text_labels(
classes, predictions["instances"].scores,
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)
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))
if args.output:
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)
print("A ...................")
demo = VisualizationDemo(cfg)
print("B ...................")
basepath = '/data1/code_base/mnt_data/kubenetra/integration/vids'
for video_id in tqdm(files):
# integration/vids/14686_.mp4
try:
print(f'this will be loaded >>>>>>> /mnt/az/kubenetra/blob_vid/{video_id}.mp4')
video = cv2.VideoCapture(f'{basepath}/{video_id}.mp4')
print("E>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
# video = cv2.VideoCapture('/app/new_clip_resized_resized.mp4')
width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
# print(f'width is {width}')
height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
frames_per_second = video.get(cv2.CAP_PROP_FPS)
img_pixels = height*width
if frames_per_second ==0:
pass
else:
num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
print('<<<<<<<<<<<<<<<<<<<<< ',video.get(cv2.CAP_PROP_FRAME_COUNT))
#######################
duration = num_frames/frames_per_second
print('num_frames is ',num_frames)
# print(f'duration is {duration} and fps is {frames_per_second}')
counter = 0
frames=[]
all_preds = list(demo.run_on_video(video))
i=1
total_frames = num_frames
# while num_frames!=0:
for num_frame, semantic_predictions in enumerate(all_preds):
# semantic_predictions = next(all_preds)
# semantic_predictions = item
objs = []
for s in semantic_predictions:
obj = {}
obj["label"] = s["text"]
obj['area_percentage'] = float("{0:.2f}".format(s['area']/img_pixels))
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/1000000))
obj["score"] = float("{0:.2f}".format(score_ave))
obj["count"] = n
u_objs.append(obj)
frame = {
"frame":i,
"instances": objs,
"objects": u_objs,
}
# print('num_frame is ',total_frames - num_frames + 1)
print('num_frame is ',num_frame + 1)
# counter+=1
# num_frames-=1
# i+=1
frames.append(frame)
cv2.destroyAllWindows()
data = {
"video": {
"meta": {},
"base_uri": "https://videobank.blob.core.windows.net/videobank",
"folder": args.video_input,
"output-frame-path": "pipeline/detectron2"
},
"ml-data": {
"object-detection": {
"meta": {'duration':duration, 'fps':frames_per_second,'len_frames':len(frames)},
"video": {},
"frames": frames
}
}
}
# print(f'data is {data}')
# try:
# os.remove(f'./blob_vid/{video_id}.txt')
# except OSError:
# pass
# return data
print(f'writing OD outs inside >>> {basepath}/{video_id}.json')
with open(f'{basepath}/{video_id}.json', 'w') as f:
json.dump(data,f)
except Exception as e:
print(e)
with open('./err_vids.txt','a') as f:
f.write(str(e))
pass