def _main(args, model):
logger = logging.getLogger(__name__)
if args.video_file is not None:
gen = get_frames(args.video_file)
else:
gen = get_infos(args.info)
frame_poses = []
for frame_num, im in gen:
logger.info('Processing frame num: {}'.format(frame_num))
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 cls_keyps is not None:
poses = [
convert_pose_data(pose)
for box, pose in zip(cls_boxes[1], cls_keyps[1])
if box[-1] > BOX_THRESH
]
else:
poses = []
frame_poses.append(poses)
if args.video_file is not None:
write_frame_poses(args, frame_poses)
else:
calc_error(args, frame_poses)
def post(self):
if 'image' not in self.request.files:
raise tornado.web.HTTPError(400, "missing field 'image'")
image = self.request.files['image'][0]
if not image['content_type'].startswith('image/'):
raise tornado.web.HTTPError(
400, "wrong content-type '{}'. Expecting 'image/*'".format(
image['content_type']))
nparr = np.fromstring(image['body'], np.uint8)
im = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
timers = defaultdict(Timer)
try:
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.application.model, im, None, timers=timers)
except Exception as e:
print(e)
raise tornado.web.HTTPError(500)
output = vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
'output',
'/tmp/',
cls_boxes,
cls_segms,
cls_keyps,
dataset=self.application.dummy_coco_dataset,
show_class=True,
thresh=0.7,
kp_thresh=2,
ext='png')
with open('/tmp/output.png', 'rb') as fd:
self.write(fd.read())
self.finish()
def main():
args = parser.parse_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()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
'''
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
'''
#for i, im_name in enumerate(im_list):
#out_name = os.path.join(
# args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')
#)
#logger.info('Processing {} -> {}'.format(im_name, out_name))
#im = cv2.imread(im_name)
hintDataURL = bottle.request.forms.get("hint")
hintDataURL = re.sub('^data:image/.+;base64,', '', hintDataURL)
hintDataURL = base64.urlsafe_b64decode(hintDataURL.encode("ascii"))
hintDataURL = np.fromstring(hintDataURL, dtype=np.uint8)
hintDataURL = cv2.imdecode(hintDataURL, -1)
hstr = str(np.random.randint(100, 999))
cv2.imwrite('record/' + hstr + '.hint.png', hintDataURL)
im = cv2.imread('record/' + hstr + '.hint.png')
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)
return 'ok'
def main(args):
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, frame, None, timers=timers)
image = vis_utils.vis_one_image_opencv(np.array(frame),
cls_boxes,
cls_segms,
cls_keyps,
thresh=0.7,
kp_thresh=2,
show_box=True,
show_class=True)
cv2.imshow('camera', image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
print("Time:", time.time() - t)
cap.release()
cv2.destroyAllWindows()
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg()
dummy_dataset = dummy_datasets.get_cifar100_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 main(args):
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
# get the weight path
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(args.weights)
#dummy_coco_dataset = dummy_datasets.get_coco_dataset()
det_dir = os.path.join(args.input_dir, 'det')
if not os.path.exists(det_dir):
os.makedirs(det_dir)
txt_file = os.path.join(det_dir, "det.txt")
fid = open(txt_file, 'w')
img_dir = os.path.join(args.input_dir, "img1")
img_list = os.listdir(img_dir)
img_list = sorted(img_list)
for i in range(len(img_list)):
print("processing: %d/%d" % (i + 1, len(img_list)))
img_name = img_list[i][:-4]
img_idx = int(img_name)
img_path = os.path.join(img_dir, img_list[i])
frame = cv2.imread(img_path)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, frame, None, None)
vis_utils.write_txt(fid, img_idx, cls_boxes)
fid.close()
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()
#jasonj
#dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
#jasonj
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, "infer_res.jpg", 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)')
def pipeline_mask(im):
if im is None:
print("im is null!")
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))
#print('===========================boxs_list:')
boxs_list = vis_utils.get_boxes_image(cls_boxes,
cls_segms,
cls_keyps,
thresh=0.7,
dataset=dummy_coco_dataset)
#print(boxs_list)
#for i in range(len(boxs_list)):
# box = boxs_list[i]
#drawBoxOnImg(im,box[1],box[2],box[3],box[4],0,0,frame)
#frame+=1
return boxs_list
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 extract_segments(self, im_path, im):
""" Use Detectron to extract all the segments in the image,
their corresponding classes,
and their binary masks"""
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.model, im, None, timers=timers)
self.logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
# TODO #srishti error/bug here if no relevant segments found l:125
segmented_images, classes, scores, segmented_binary_masks = vis_utils.segmented_images_in_original_image_size(
im,
im_path,
self.conf['io']['output_dir'],
cls_boxes,
cls_segms,
cls_keyps,
dataset=self.dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
return segmented_images, classes, scores, segmented_binary_masks
def detect(self, im, id):
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(id):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.model, im, None, timers=timers)
self.logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
imsw = vis_utils.vis_one_image_opencv(im,
cls_boxes,
cls_segms,
cls_keyps,
self.confidence,
2,
show_box=True,
dataset=self.dummy_coco_dataset,
show_class=True)
boxes, segms, keypoints, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
bboxes = BBoxDetArray()
bboxes.header = std_msgs.msg.Header()
if boxes is not None:
for i in range(len(boxes)):
box = boxes[i][0:4]
score = boxes[i][4]
cls = self.dummy_coco_dataset.classes[classes[i]]
if (score >= self.confidence):
bbox = BBox(box[0], box[1], box[2], box[3])
bbox_det = BBoxDet(bbox, score, cls)
bboxes.bboxes.append(bbox_det)
return imsw, bboxes
def main(args):
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()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
video_frame_length = video_frame(args) #Yunhan Yang pass in a list to save all the frames
print ("The video has length " + str(video_frame_length) + " frames")
f_image_path = args.im_or_folder+ "frame%d.jpg" % 0
fr = cv2.imread(f_image_path, 0)
origin_width, origin_height = fr.shape[:2]
for x in range(0,video_frame_length):
im_list = [args.im_or_folder+"frame" + str(x) + ".jpg"] #Yunhan Yang have to save frame in real folder and then read in
#maybe need need double for loop for list of frames
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)'
)
#Yunhan Yang edit
if not os.path.exists(args.im_or_folder+ "/video"):
os.makedirs(args.im_or_folder+ "/video")
#Yunhan Yang edit Detectron/lib/utils/vis.py add make result as jpg than pdf
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)')
t1 = time.time()
im = vis_utils.vis_one_image_opencv(im,
cls_boxes,
segms=cls_segms,
keypoints=cls_keyps,
thresh=0.7,
kp_thresh=2,
show_box=True,
dataset=dummy_coco_dataset,
show_class=True)
# vis_utils.vis_one_image(
# im[:, :, ::-1], # BGR -> RGB for visualization
# im_name,
# args.output_dir,
# cls_boxes,
# cls_segms,
# cls_keyps,
# dataset=dummy_coco_dataset,
# box_alpha=0.3,
# show_class=True,
# thresh=0.7,
# kp_thresh=2
# )
t2 = time.time() - t1
print("vis time %f ms" % (t2 * 1000))
cv2.imwrite(
args.output_dir + '/' + im_name.split('/')[-1].split('.')[0] +
'.jpg', im)
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
cfg.TRAIN.IMS_PER_BATCH = 1
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps, \
cls_refined_segms, cls_refined_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,
os.path.join(args.output_dir, 'vis_local'),
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2)
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
os.path.join(args.output_dir, 'vis_refined'),
cls_boxes,
cls_refined_segms,
cls_refined_keyps,
dataset=dummy_coco_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.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
# for i, im_name in enumerate(im_list):
# out_name = os.path.join(
# args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')
# )
# logger.info('Processing {} -> {}'.format(im_name, out_name))
#set webcam
cam = cv2.VideoCapture(0)
while True:
#Fetch image from camera
ret_val, im = cam.read()
#uncomment to resize image
#im = cv2.resize(im, (1200,1024))
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 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
"dummy_name",
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
cv2.destroyAllWindows()
def predict(self,im):
#class_str_list = []
data_list = []
with c2_utils.NamedCudaScope(self.gpu_id):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(self.model, im, None, None
)
#get box classes
if isinstance(cls_boxes, list):
boxes, segms, keypoints, classes = self.convert_from_cls_format(cls_boxes, cls_segms, cls_keyps)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < self.score_thresh:
return data_list
#get score
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
sorted_inds = np.argsort(-areas)
#nms between classes
#im2 = cv2.cvtColor(im,cv2.COLOR_RGB2BGR)
#result2= im2.copy()
if (len(sorted_inds) > 0):
nmsIndex = self.nms_between_classes(boxes, self.class_nms_thresh) #阈值为0.9，阈值越大，过滤的越少
for i in xrange(len(nmsIndex)):
bbox = boxes[nmsIndex[i], :4]
score = boxes[nmsIndex[i], -1]
if score < self.score_thresh:
continue
#get class-str
class_str = self.get_class_string(classes[nmsIndex[i]], score, self.dummy_coco_dataset)
#score thresd per class
if self.per_class_thresh:
if 'autotruck' == class_str and score < self.autotruck_score_thresh:
continue
if 'forklift' == class_str and score < self.forklift_score_thresh:
continue
if 'digger' == class_str and score < self.digger_score_thresh:
continue
if 'car' == class_str and score < self.car_score_thresh:
continue
if 'bus' == class_str and score < self.bus_score_thresh:
continue
if 'tanker' == class_str and score < self.tanker_score_thresh:
continue
if 'person' == class_str and score < self.person_score_thresh:
continue
if 'minitruck' == class_str and score < self.minitruck_score_thresh:
continue
if 'minibus' == class_str and score < self.minibus_score_thresh:
continue
single_data = {"cls":class_str,"score":float('%.2f' % score),"bbox":{"xmin":int(bbox[0]),"ymin":int(bbox[1]),"xmax":int(bbox[2]),"ymax":int(bbox[3])}}
data_list.append(single_data)
#construcrion - data_list
return data_list
def __call__(self, img):
timers = defaultdict(Timer)
im = cv2.resize(img, (540, 400))
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
MODEL, im, None, timers=timers)
# print cls_boxes, cls_segms, cls_keyps
return cls_boxes, cls_segms, cls_keyps
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.TEST.WEIGHTS = args.weights
cfg.NUM_GPUS = 1
logger.info('about to assert')
assert_and_infer_cfg()
logger.info('About to initialise model')
model = infer_engine.initialize_model_from_cfg()
logger.info("Done initialising")
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) + '.png'))
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)')
segmented_images, classes, scores, segmented_binary_masks = vis_utils.segmented_images_in_original_image_size(
im,
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)
found = False
for index, value in enumerate(segmented_images):
if classes[index] == args.class_label and not found:
logger.info('Writing output file to: {}'.format(str(i)))
bin_mask = vis_utils.vis_binary_mask(
im, segmented_binary_masks[index])
cv2.imwrite(out_name, value)
cv2.imwrite(out_name.rstrip(".png") + "bin.png", bin_mask)
found = True
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()
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]
"""
Add support for webcam
"""
# Set and get camera from OpenCV
cam = cv2.VideoCapture(0)
im_name = 'tmp_im'
while True:
# Fetch image from camera
_, 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))
if 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=0.7,
kp_thresh=2,
ext='jpg' # default is PDF, but we want JPG.
)
cv2.destroyAllWindows()
def main(args):
logger = logging.getLogger(__name__)
merge_cfg_from_file(args.cfg)
cfg.NUM_GPUS = 1
args.weights = cache_url(args.weights, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg(args.weights)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
# im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
im_list = search(args.im_or_folder, args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
#for i, im_name in im_list:
#out_name = os.path.join(
# args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')
#)
out_name = im_name.replace(args.im_or_folder, args.output_dir)
par_path = os.path.dirname(out_name)
if not os.path.exists(par_path):
os.makedirs(par_path)
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,
par_path,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2,
ext='png'
)
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_vg3k_dataset()
if args.use_vg3k else dummy_datasets.get_coco_dataset())
if os.path.isdir(args.im_or_folder):
im_list = sorted(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) + '.npz')
)
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
if im is None:
logger.info('Unable to read image, skipping.')
continue
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)'
)
boxes, segms, classes = convert(cls_boxes, cls_segms)
classes = np.array(classes, dtype=np.uint16)
resolution = segms[0]['size']
segms = np.array([x['counts'] for x in segms]) # Run-length encoding
valid = boxes[:, 4] >= args.thresh
if args.filter_classes:
valid &= np.isin(classes, all_classes)
boxes = boxes[valid].copy()
classes = classes[valid].copy()
segms = segms[valid].copy()
output_name = os.path.basename(im_name)
np.savez(args.output_dir + '/' + output_name, boxes=boxes, segments=segms, classes=classes, resolution=resolution)
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()
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]
test_ids = []
rles = []
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)')
new_test_ids, new_rles = vis_utils.make_submission(im[:, :, ::-1],
im_name,
cls_boxes,
cls_segms,
cls_keyps,
thresh=0.7)
test_ids.extend(new_test_ids)
rles.extend(new_rles)
import pandas as pd
sub = pd.DataFrame()
sub['ImageId'] = test_ids
sub['EncodedPixels'] = pd.Series(rles).apply(
lambda x: ' '.join(str(y) for y in x))
sub.to_csv(args.output_dir +
'/e2e_mask_rcnn_R-50-FPN_1x-lr3e-3-nuclei-6-new.csv',
index=False)
def main(args):
logger = logging.getLogger(__name__)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = yaml.load(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()
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):
logger = logging.getLogger(__name__)
args.cfg = '/detectron/configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml'
args.weights = '/data/workspace/fbdet/models/mask_rcnn_R_101_FPN_2x/model_final.pkl'
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()
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]
im_list = []
im_list.append('/data/workspace/fbdet/test_pic/11.jpg')
video = cv2.VideoCapture('/data/pic/valid_video_00.avi')
frame = 0
while (True):
if frame > 0:
break
# ret, im = video.read()
# if im is None or ret is None:
# print("video.read() fail || video.read() is end!")
# break
im = cv2.imread(im_list[0])
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))
print('-----------------------------', frame)
boxs_list = vis_utils.get_boxes_image(cls_boxes,
cls_segms,
cls_keyps,
thresh=0.7,
dataset=dummy_coco_dataset)
print(boxs_list)
print('-----------------------------')
for i in range(len(boxs_list)):
box = boxs_list[i]
drawBoxOnImg(im, box[1], box[2], box[3], box[4], 0, 0, frame)
frame += 1
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()
for root_dir_path_1, sub_dir_path_list_1, sub_file_path_list_1 in os.walk(
args.im_or_folder):
sub_dir_path_list_1 = sorted(sub_dir_path_list_1)
for i, sub_dir_path_1 in enumerate(sub_dir_path_list_1):
for root_dir_path_2, sub_dir_path_list_2, sub_file_path_list_2 in os.walk(
os.path.join(root_dir_path_1, sub_dir_path_1)):
sub_file_path_list_2 = sorted(sub_file_path_list_2)
out_file = open(
os.path.join(args.output_dir,
sub_dir_path_1 + "_Det_ffasta.txt"), "wb")
for img_idx, sub_file_path_2 in enumerate(
sub_file_path_list_2):
im = cv2.imread(
os.path.join(root_dir_path_2, sub_file_path_2))
timers = defaultdict(Timer)
t = time.time()
if (img_idx + 1) % 1000 == 0:
sys.stdout.write(
"\rFinish {} images\n".format(img_idx + 1))
sys.stdout.flush()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers)
if isinstance(cls_boxes, list):
cls_boxes, cls_segms, cls_keyps, classes = vis_utils.convert_from_cls_format(
cls_boxes, cls_segms, cls_keyps)
if cls_boxes is None or cls_boxes.shape[0] == 0:
continue
obj_idx = 0
for cls_box, cls in zip(cls_boxes, classes):
if int(cls) != 3 and int(cls) != 6:
continue
out_file.write("{},{},{},{},{},{},{}\n".format(
img_idx + 1, obj_idx + 1, cls_box[0],
cls_box[1], cls_box[2] - cls_box[0],
cls_box[3] - cls_box[1], cls_box[4]))
obj_idx += 1
out_file.close()
print("Finish {} / {} of video sequences".format(
i + 1, len(sub_dir_path_list_1)))
break
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()
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
if os.path.isdir(args.im_or_folder):
im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
else:
im_list = [args.im_or_folder]
for i, im_name in enumerate(im_list):
out_name = os.path.join(
args.output_dir, '{}'.format(os.path.basename(im_name) + '.pdf')
)
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers
)
logger.info('Inference time: {:.3f}s'.format(time.time() - t))
for k, v in timers.items():
logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
if i == 0:
logger.info(
' \ Note: inference on the first image will be slower than the '
'rest (caches and auto-tuning need to warm up)'
)
vis_utils.vis_one_image(
im[:, :, ::-1], # BGR -> RGB for visualization
im_name,
args.output_dir,
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2
)
def execute(self, frame: FrameType) -> Tuple[bytes, bytes, bytes]:
logger = logging.getLogger(__name__)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
self.graph, frame, 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))
return (
pickle.dumps(cls_boxes),
pickle.dumps(cls_segms),
pickle.dumps(cls_keyps))
def main():
logger = logging.getLogger(__name__)
merge_cfg_from_file('/detectron/e2e_mask_rcnn_R-101-FPN_2x.yaml')
cfg.NUM_GPUS = 4
assert_and_infer_cfg()
model = infer_engine.initialize_model_from_cfg('/detectron/models/model_final.pkl')
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
# cam = cv2.VideoCapture("rtsp://192.168.128.12:554/mpeg4cif")
# cam = cv2.VideoCapture("rtsp://192.168.128.11:554/av0_1")
# cam = cv2.VideoCapture("http://192.168.128.14/video.cgi")
n = 0
tmp_file_name = '/tmp/tmp.jpg'
im0 = 0
im1 = 0
while True:
# ret_val, im = cam.read()
# cv2.imwrite(tmp_file_name, im)
im = cv2.imread('/detectron/k2m30/img/' + str(n) + '.jpg')
timers = defaultdict(Timer)
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, timers=timers
)
data = vis_utils.vis_one_image_opencv(
im, # BGR -> RGB for visualization
cls_boxes,
cls_segms,
cls_keyps,
dataset=dummy_coco_dataset,
# box_alpha=0.3,
show_class=True,
thresh=0.7,
kp_thresh=2,
# ext='png'
)
# time.sleep(0.1)
# if data == None:
# logger.info(cls_boxes)
#
# else:
n += 1
n = n % 1000
file_name = '/tmp/' + str(n) + '.jpg'
cv2.imwrite(file_name, data)
logger.info(str(n) + ' saved')
logger.info(os.path.getsize(file_name))
def predict(cfg_path, weights_path):
logger = logging.getLogger(__name__)
merge_cfg_from_file(cfg_path)
cfg.NUM_GPUS = 1
gpu_id = 0 #指定GPU
weights_path = cache_url(weights_path, cfg.DOWNLOAD_CACHE)
assert_and_infer_cfg(cache_urls=False)
model = infer_engine.initialize_model_from_cfg(weights_path, gpu_id)
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
#dummy_coco_dataset = dummy_datasets.get_illbuild_class11_dataset()
print("model is ok")
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) + '.jpg'))
logger.info('Processing {} -> {}'.format(im_name, out_name))
im = cv2.imread(im_name)
timers = defaultdict(Timer)
t = time.time()
with c2_utils.NamedCudaScope(gpu_id):
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=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_vg3k_dataset() if args.use_vg3k
else dummy_datasets.get_coco_dataset())
if args.im_or_folder == 'train0':
#im_list = glob.iglob(args.im_or_folder + '/*.' + args.image_ext)
im_list = cPickle.load(open('train_list.pkl'))
pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_train2014'
im_list = im_list[:40000]
elif args.im_or_folder == 'train1':
im_list = cPickle.load(open('train_list.pkl'))
pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_train2014'
im_list = im_list[40000:]
elif args.im_or_folder == 'val':
im_list = cPickle.load(open('val_list.pkl'))
pre_folder = '/mnt/storage/jialinwu/detectron/detectron/datasets/data/coco/coco_val2014'
elif args.im_or_folder == 'test0':
im_list = cPickle.load(open('test_list.pkl'))
im_list = im_list[:40000]
pre_folder = '../ARNet/image_captioning/data/images/test2015'
elif args.im_or_folder == 'test1':
im_list = cPickle.load(open('test_list.pkl'))
im_list = im_list[40000:]
pre_folder = '../ARNet/image_captioning/data/images/test2015'
for i in tqdm(range(len(im_list))):
im_name = pre_folder + '/' + im_list[i]
if im_name[-4:] != '.jpg':
continue
im = cv2.imread(im_name)
timers = defaultdict(Timer)
imgid = int(im_list[i][:-4].split('_')[-1])
if args.im_or_folder == 'val':
save_name = '/mnt/storage/jialinwu/seg_every_thing/npz_features/coco_val2014/%d.npz' % imgid
else:
save_name = '/mnt/storage/jialinwu/seg_every_thing/npz_features/coco_train2014/%d.npz' % imgid
with c2_utils.NamedCudaScope(0):
cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
model, im, None, save_name, timers=timers)
'''
def main(args):
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = yaml.load(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]
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
cfg.TEST.WEIGHTS = pkl
cfg.NUM_GPUS = 1
assert_and_infer_cfg()
model = model_engine.initialize_model_from_cfg()
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()
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):
dummy_coco_dataset = dummy_datasets.get_coco_dataset()
cfg_orig = yaml.safe_load(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]
merge_cfg_from_cfg(cfg_orig)
merge_cfg_from_file(yml)
if len(pkl) > 0:
cfg.TEST.WEIGHTS = pkl
cfg.NUM_GPUS = 1
assert_and_infer_cfg()
model = model_engine.initialize_model_from_cfg()
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()
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)
