def show_result(self,
data,
result,
img_norm_cfg,
dataset='coco',
score_thr=0.3):
img_tensor = data['img'][0]
#img_tensor_t = data['img_t'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
#imgs_t = tensor2imgs(img_tensor_t,**)
assert len(imgs) == len(img_metas)
if isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, list):
class_names = dataset
else:
raise TypeError('dataset must be a valid dataset name or a list'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(result)
]
labels = np.concatenate(labels)
bboxes = np.vstack(result)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def show_result(self,
data,
result,
img_norm_cfg,
frame_index,
show=False,
dataset=None,
score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32) # category_id -1
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
show=show,
class_names=class_names,
wait_time=1,
out_file="output/polyp/" +
str("{:04d}".format(frame_index)) + ".png",
score_thr=score_thr)
def show_gt_result(self,
data,
bbox_gts,
label_gts,
img_norm_cfg,
mask_gts=None,
dataset=None,
image_dir=None,
show=False,
image_name=None):
bbox_gts = bbox_gts.data[0]
label_gts = label_gts.data[0]
if mask_gts:
mask_gts = mask_gts.data[0]
else:
mask_gts = []
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta, bbox_gt, label_gt, mask_gt in zip(
imgs, img_metas, bbox_gts, label_gts, mask_gts):
h, w, _ = img_meta['pad_shape']
img_show = img[:h, :w, :]
bboxes = bbox_gt.cpu().numpy()
# draw segmentation masks
if len(mask_gts) > 0:
segms = mask_gt
for i in range(segms.shape[0]):
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = segms[i, :, :].astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = label_gt.cpu().numpy() - 1
assert image_dir and image_name, 'image_dir and image_name can not be None'
if not osp.exists(image_dir):
os.mkdir(image_dir)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
text_color='white',
class_names=class_names,
score_thr=0,
show=show,
out_file=osp.join(image_dir, image_name))
def vis_seg(data, result, img_norm_cfg, data_id, colors, score_thr, save_dir):
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
class_names = get_classes('tianchi')
for img, img_meta, cur_result in zip(imgs, img_metas, result):
if cur_result is None:
continue
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
seg_label = cur_result[0]
seg_label = seg_label.cpu().numpy().astype(np.uint8)
cate_label = cur_result[1]
cate_label = cate_label.cpu().numpy()
score = cur_result[2].cpu().numpy()
vis_inds = score > score_thr
seg_label = seg_label[vis_inds]
num_mask = seg_label.shape[0]
cate_label = cate_label[vis_inds]
cate_score = score[vis_inds]
mask_density = []
for idx in range(num_mask):
cur_mask = seg_label[idx, :, :]
cur_mask = mmcv.imresize(cur_mask, (w, h))
cur_mask = (cur_mask > 0.5).astype(np.int32)
mask_density.append(cur_mask.sum())
orders = np.argsort(mask_density)
seg_label = seg_label[orders]
cate_label = cate_label[orders]
cate_score = cate_score[orders]
seg_show = img_show.copy()
for idx in range(num_mask):
idx = -(idx+1)
cur_mask = seg_label[idx, :,:]
cur_mask = mmcv.imresize(cur_mask, (w, h))
cur_mask = (cur_mask > 0.5).astype(np.uint8)
if cur_mask.sum() == 0:
continue
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8)
cur_mask_bool = cur_mask.astype(np.bool)
seg_show[cur_mask_bool] = img_show[cur_mask_bool] * 0.5 + color_mask * 0.5
cur_cate = cate_label[idx]
cur_score = cate_score[idx]
label_text = class_names[cur_cate]
#label_text += '|{:.02f}'.format(cur_score)
# center
center_y, center_x = ndimage.measurements.center_of_mass(cur_mask)
vis_pos = (max(int(center_x) - 10, 0), int(center_y))
cv2.putText(seg_show, label_text, vis_pos,
cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255)) # green
mmcv.imwrite(seg_show, '{}/{}.jpg'.format(save_dir, data_id))
def forward_train(self,
img,
img_metas,
gt_bboxes=None,
gt_bboxes_ignore=None):
"""
Args:
img (Tensor): Input images of shape (N, C, H, W).
Typically these should be mean centered and std scaled.
img_metas (list[dict]): A List of image info dict where each dict
has: 'img_shape', 'scale_factor', 'flip', and may also contain
'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
For details on the values of these keys see
:class:`mmdet.datasets.pipelines.Collect`.
gt_bboxes (list[Tensor]): Each item are the truth boxes for each
image in [tl_x, tl_y, br_x, br_y] format.
gt_bboxes_ignore (None | list[Tensor]): Specify which bounding
boxes can be ignored when computing the loss.
Returns:
dict[str, Tensor]: A dictionary of loss components.
"""
if self.train_cfg.rpn.get('debug', False):
self.rpn_head.debug_imgs = tensor2imgs(img)
x = self.extract_feat(img)
rpn_outs = self.rpn_head(x)
rpn_loss_inputs = rpn_outs + (gt_bboxes, img_metas)
losses = self.rpn_head.loss(*rpn_loss_inputs,
gt_bboxes_ignore=gt_bboxes_ignore)
return losses
def forward_train(self,
img,
img_metas,
gt_bboxes,
gt_labels,
gt_bboxes_ignore=None):
x = self.extract_feat(
img) # each tensor in this tuple is corresponding to a level.
if every_n_local_step(self.train_cfg.get('vis_every_n_iters', 2000)):
# TODO remove hardcode
add_image_summary(
'image/origin',
tensor2imgs(img,
mean=[123.675, 116.28, 103.53],
std=[57.12, 58.395, 57.375],
to_rgb=True)[0], gt_bboxes[0].cpu(),
gt_labels[0].cpu())
if isinstance(x[0], tuple):
feature_p = x[0]
else:
feature_p = x
add_feature_summary('feature/x',
feature_p[-1].detach().cpu().numpy())
outs = self.bbox_head(x)
loss_inputs = outs + (gt_bboxes, gt_labels, img_metas, self.train_cfg)
losses = self.bbox_head.loss(*loss_inputs,
gt_bboxes_ignore=gt_bboxes_ignore)
return losses
def show_result(self, data, result, score_thr=0.5):
rects, scores, char_bbox_results, texts = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
img_name = img_metas[0]['filename'].split('/')[-1]
vis_dir = './vis/'
if not os.path.exists(vis_dir):
os.makedirs(vis_dir)
h, w, _ = img_metas[0]['img_shape']
img_show = imgs[0][:h, :w, :]
rects = np.array(rects)
scores = np.array(scores)
ind = scores > score_thr
rects = rects[ind, :, :]
texts = [texts[i] for i in range(len(texts)) if ind[i]]
self.imshow_det_bboxes(img_show,
rects,
texts,
out_file=vis_dir + img_name)
def show_rmask(data,
result,
img_norm_cfg,
class_names,
score_thr=0.3,
file_name='0.png'):
bbox_result, segm_result, rbbox_result = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
rbboxes = np.vstack(rbbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw rbbox
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
img = imread(img_show)
scores = rbboxes[:, -1]
inds = scores > score_thr
bboxes = bboxes[inds, :]
rbboxes = rbboxes[inds, :8]
labels = labels[inds]
rbbox_color = (0, 0, 255)
text_color = (0, 255, 0)
font_scale = 0.5
'''
for rbbox, bbox, label in zip(rbboxes, bboxes, labels):
bbox_int = bbox.astype(np.int32)
rbbox_int = rbbox.astype(np.int32)
rbbox_int = rbbox_int.reshape(4,2)
cv2.drawContours(img,[rbbox_int],0,rbbox_color,2)
label_text = class_names[
label] if class_names is not None else 'cls {}'.format(label)
if len(bbox) > 4:
label_text += '|{:.02f}'.format(bbox[-1])
cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2),
cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color)
'''
cv2.imwrite(file_name, img)
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_metas = data['img_meta'][0].data[0]
if 'img_raw' in data:
img_tensor = data['img_raw'][0]
norm_factor = {'mean': [0, 0, 0], 'std': [1, 1, 1], 'to_rgb': True}
filename = os.path.join(
'results',
data['img_meta'][0].data[0][0]['filename'].split('/')[-1])
else:
img_tensor = data['img'][0]
norm_factor = img_metas[0]['img_norm_cfg']
filename = None
imgs = tensor2imgs(img_tensor, **norm_factor)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
show=False,
out_file=filename)
def visualize_gt_bboxes(self, imgs, gt_bboxes, img_meta):
imgs = tensor2imgs(imgs, mean=(123.675, 116.28, 103.53), std=(58.395, 57.12, 57.375))
batch_num = 1
for img, gt_bbox in zip(imgs, gt_bboxes):
filename = 'tests/iter_{}_batchnum_{}.png'.format(self.iteration, batch_num)
mmcv.imshow_bboxes(img, gt_bbox.cpu().numpy(), show=False, out_file=filename)
batch_num += 1
breakpoint()
def show_result(
self,
data,
result,
img_norm_cfg,
dataset="coco",
score_thr=0.3,
):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data["img"][0]
img_metas = data["img_meta"][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)) or dataset is None:
class_names = dataset
else:
raise TypeError(
"dataset must be a valid dataset name or a sequence"
" of class names, not {}".format(type(dataset))
)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta["img_shape"]
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(
0, 256, (1, 3), dtype=np.uint8
)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = (
img_show[mask] * 0.5 + color_mask * 0.5
)
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(
img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
)
def single_gpu_test(model,
data_loader,
show=False,
out_dir=None,
show_score_thr=0.3):
model.eval()
results = []
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
filename = 'result.txt'
with open(filename, 'w') as f:
f.write(result)
# print('in api test result: ')
# print(type(result))
# print(result)
batch_size = len(result)
if show or out_dir:
if batch_size == 1 and isinstance(data['img'][0], torch.Tensor):
img_tensor = data['img'][0]
else:
img_tensor = data['img'][0].data[0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
for i, (img, img_meta) in enumerate(zip(imgs, img_metas)):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir, img_meta['ori_filename'])
else:
out_file = None
model.module.show_result(
img_show,
result[i],
show=show,
out_file=out_file,
score_thr=show_score_thr)
with open(filename, 'w', 'UTF-8') as f:
f.write(result)
# encode mask results
if isinstance(result[0], tuple):
result = [(bbox_results, encode_mask_results(mask_results))
for bbox_results, mask_results in result]
results.extend(result)
for _ in range(batch_size):
prog_bar.update()
return results
def show_result(self,
data,
result,
img_norm_cfg,
dataset=None,
score_thr=0.3,
outfile=None):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
# solve UnboundLocalError: local variable '_mlvl_bboxes' referenced before assignment
# h, w, _ = img_meta['img_shape']
h, w, _ = img_meta['ori_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr,
out_file=outfile)
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'].data
print(img_tensor.shape)
img_metas = data['img_meta'].data[0]
print(img_metas)
imgs = tensor2imgs(
img_tensor, **{
'mean': np.array([0.5, 0.5, 0.5]),
'std': np.array([255., 255., 255.]),
'to_rgb': False
})
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
print(segms)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
print('amsk shape', mask.shape)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
mmcv.imshow_det_bboxes(img_show,
bboxes,
labels,
class_names=class_names,
score_thr=score_thr)
def forward_train(self, img, img_meta, gt_bboxes=None):
if self.train_cfg.rpn.get('debug', False):
self.rpn_head.debug_imgs = tensor2imgs(img)
x = self.extract_feat(img)
rpn_outs = self.rpn_head(x)
rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, self.train_cfg.rpn)
losses = self.rpn_head.loss(*rpn_loss_inputs)
return losses
def show_result(self, data, result, dataset=None, score_thr=0.3):
if isinstance(result, tuple):
bbox_result, segm_result = result
else:
bbox_result, segm_result = result, None
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
if dataset is None:
class_names = self.CLASSES
elif isinstance(dataset, str):
class_names = get_classes(dataset)
elif isinstance(dataset, (list, tuple)):
class_names = dataset
else:
raise TypeError(
'dataset must be a valid dataset name or a sequence'
' of class names, not {}'.format(type(dataset)))
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw segmentation masks
if segm_result is not None:
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
for i in inds:
color_mask = np.random.randint(0,
256, (1, 3),
dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
# draw bounding boxes
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
print("img_meta: {}".format(img_meta))
mmcv.imshow_det_bboxes(
img_show,
bboxes,
labels,
# class_names=class_names,
class_names=[str(i) for i in range(len(class_names))],
score_thr=score_thr,
gt_bboxes=data['gt_bboxes'][0][0].numpy(),
gt_labels=(data['gt_labels'][0][0] - 1).numpy())
def show_rbbox_color(data,
result,
img_norm_cfg,
class_names,
score_thr=0.3,
file_name='0.png'):
rbbox_result = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
rbboxes = np.vstack(rbbox_result)
# draw rbbox
labels = [
np.full(rbbox.shape[0], i, dtype=np.int32)
for i, rbbox in enumerate(rbbox_result)
]
labels = np.concatenate(labels)
img = imread(img_show)
scores = rbboxes[:, -1]
inds = scores > score_thr
rbboxes = rbboxes[inds, :8]
labels = labels[inds]
# rbbox_color = ncolors(16)
rbbox_color = [[247, 11, 11], [244, 103, 19], \
[250, 199, 48], [220, 245, 45], [150, 247, 52], \
[69, 244, 44], [18, 243, 75], [27, 251, 167], \
[38, 248, 248], [18, 158, 242], [15, 74, 249], \
[33, 2, 253], [147, 44, 250], [220, 29, 248], \
[243, 16, 186], [250, 43, 121]]
text_color = (0, 255, 0)
font_scale = 0.5
for rbbox, score, label in zip(rbboxes, scores, labels):
rbbox_int = rbbox.astype(np.int32)
rbbox_int = rbbox_int.reshape(4, 2)
cv2.drawContours(img, [rbbox_int], 0, rbbox_color[label], 2)
# label_text = class_names[
# label] if class_names is not None else 'cls {}'.format(label)
# label_text += '|{:.02f}'.format(score)
# cv2.putText(img, label_text, (rbbox_int[0][0], rbbox_int[0][1] - 2),
# cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color)
cv2.imwrite(file_name, img)
def visualize_proposals(self, imgs, proposals, gt_bboxes):
img = tensor2imgs(imgs, mean=(123.675, 116.28, 103.53), std=(58.395, 57.12, 57.375))
batch_num = 0
for cur_proposals, cur_gt_bboxes in zip(proposals, gt_bboxes):
bboxes = []
cur_proposals = cur_proposals.cpu().numpy()
for bbox in cur_proposals:
bboxes.append([bbox[0], bbox[1], bbox[2], bbox[3]])
filename = 'tests2/iter_{}_batch_{}.png'.format(self.iteration, batch_num)
self.show_bboxes_gt_bboxes(img[0], np.array(bboxes), gt_bboxes=cur_gt_bboxes, out_file=filename)
batch_num += 1
def single_gpu_test(model,
data_loader,
show=False,
out_dir=None,
show_score_thr=0.3,
save_crop_image = True):
model.eval()
results = []
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
if show or out_dir:
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir, img_meta['ori_filename'])
else:
out_file = None
model.module.show_result(
img_show,
result,
show=show,
out_file=out_file,
score_thr=show_score_thr)
# encode mask results
if isinstance(result, tuple):
bbox_results, mask_results = result
if save_crop_image:
crop_image(result, INPUT_PATH, OUTPUT_PATH,i)
encoded_mask_results = encode_mask_results(mask_results)
result = bbox_results, encoded_mask_results
results.append(result)
batch_size = len(data['img_metas'][0].data)
for _ in range(batch_size):
prog_bar.update()
return results
def show_result(self, data, result, img_norm_cfg, dataset=None, top_k=20):
"""Show RPN proposals on the image.
Although we assume batch size is 1, this method supports arbitrary
batch size.
"""
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
assert len(imgs) == len(img_metas)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
mmcv.imshow_bboxes(img_show, result, top_k=top_k)
def show_rmask_single(data,
result,
img_norm_cfg,
class_names,
score_thr=0.0,
file_name='0.png'):
bbox_result, segm_result, rbbox_result = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
rbboxes = np.vstack(rbbox_result)
rbboxes = rbboxes[:, :8]
segms = mmcv.concat_list(segm_result)
inds = np.where(bboxes[:, -1] > score_thr)[0]
rbbox_color = (0, 0, 255)
text_color = (0, 255, 0)
font_scale = 0.5
for i in inds:
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
img_show = imgs[0][:h, :w, :]
color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8)
mask = maskUtils.decode(segms[i]).astype(np.bool)
img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5
rbbox_int = rbboxes[i].astype(np.int32)
rbbox_int = rbbox_int.reshape(4, 2)
cv2.drawContours(img_show, [rbbox_int], 0, rbbox_color, 2)
path_str = 'test_out_img/' + str(i) + '.png'
cv2.imwrite(path_str, img_show)
def plot_track_results(self, img, img_meta, track_bboxes, track_ids):
img = tensor2imgs(img, **self.cfg.img_norm_cfg)[0]
out_folder = os.path.join(self.cfg.out_path,
str(img_meta[0]['video_id']))
os.makedirs(out_folder, exist_ok=True)
out_file = os.path.join(
out_folder, '{}.png'.format(str(img_meta[0]['frame_id']).zfill(3)))
img = mmcv.imshow_track_bboxes(img,
track_bboxes,
track_ids,
thickness=2,
font_scale=0.4,
show=False,
draw_score=False,
out_file=out_file)
def forward_train(self,
img,
img_meta,
gt_bboxes=None,
gt_bboxes_ignore=None):
if self.train_cfg.rpn.get('debug', False):
self.rpn_head.debug_imgs = tensor2imgs(img)
x = self.extract_feat(img)
rpn_outs = self.rpn_head(x)
# proposal_list = self.simple_test_rpn(x, img_meta, self.test_cfg.rpn)
rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, self.train_cfg.rpn)
losses = self.rpn_head.loss(
*rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore)
return losses
def show_bbox(data,
result,
img_norm_cfg,
class_names,
score_thr=0.3,
file_name='0.png'):
bbox_result = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
bboxes = np.vstack(bbox_result)
# draw rbbox
labels = [
np.full(bbox.shape[0], i, dtype=np.int32)
for i, bbox in enumerate(bbox_result)
]
labels = np.concatenate(labels)
img = imread(img_show)
scores = bboxes[:, -1]
inds = scores > score_thr
bboxes = bboxes[inds, :]
labels = labels[inds]
bbox_color = (0, 255, 0)
text_color = (0, 255, 0)
font_scale = 0.5
for bbox, label in zip(bboxes, labels):
bbox_int = bbox.astype(np.int32)
cv2.rectangle(img, (bbox_int[0], bbox_int[1]),
(bbox_int[2], bbox_int[3]), bbox_color, 1)
label_text = class_names[
label] if class_names is not None else 'cls {}'.format(label)
if len(bbox) > 4:
label_text += '|{:.02f}'.format(bbox[-1])
cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2),
cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color)
cv2.imwrite(file_name, img)
def show_rbbox(data,
result,
img_norm_cfg,
class_names,
score_thr=0.3,
file_name='0.png'):
rbbox_result = result
img_tensor = data['img'][0]
img_metas = data['img_meta'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_norm_cfg)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
rbboxes = np.vstack(rbbox_result)
# draw rbbox
labels = [
np.full(rbbox.shape[0], i, dtype=np.int32)
for i, rbbox in enumerate(rbbox_result)
]
labels = np.concatenate(labels)
img = imread(img_show)
scores = rbboxes[:, -1]
inds = scores > score_thr
rbboxes = rbboxes[inds, :8]
labels = labels[inds]
rbbox_color = (0, 255, 0)
text_color = (0, 255, 0)
font_scale = 0.5
for rbbox, score, label in zip(rbboxes, scores, labels):
rbbox_int = rbbox.astype(np.int32)
rbbox_int = rbbox_int.reshape(4, 2)
cv2.drawContours(img, [rbbox_int], 0, rbbox_color, 1)
label_text = class_names[
label] if class_names is not None else 'cls {}'.format(label)
label_text += '|{:.02f}'.format(score)
cv2.putText(img, label_text,
(rbbox_int[0][0], rbbox_int[0][1] - 2),
cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color)
cv2.imwrite(file_name, img)
def single_gpu_test(model,
img_data_list,
show=False,
out_dir=None,
show_score_thr=0.3):
model.eval()
results = []
for (img, img_meta) in img_data_list:
data = {
"img_metas": [DC([[img_meta]], cpu_only=True)],
"img": [img.unsqueeze(0).contiguous()]
}
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
if show or out_dir:
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir,
osp.basename(img_meta['ori_filename']))
else:
out_file = None
show_result(img_show,
result,
show=show,
out_file=out_file,
score_thr=show_score_thr)
# encode mask results
if isinstance(result, tuple):
bbox_results, mask_results = result
encoded_mask_results = encode_mask_results(mask_results)
result = bbox_results, encoded_mask_results
results.append(result)
return results
def single_gpu_test(model,
data_loader,
show=False,
out_dir=None,
show_score_thr=0.3):
model.eval()
results = []
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
# for one picture, it returns several bbox, each bbox consists of one bbox and one segmentation,
# in our case, segmentation is a blank list.
result = model(return_loss=False, rescale=True, **data)
# print('\n', 'result in single_gpu_test: ', result)
# the shape of results is the length of the test set.
results.append(result)
# print('final result in single_gpu_test: ', results, '\n', 'final result shape: ', len(results))
if show or out_dir:
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir, img_meta['filename'])
else:
out_file = None
model.module.show_result(img_show,
result,
show=show,
out_file=out_file,
score_thr=show_score_thr)
batch_size = data['img'][0].size(0)
for _ in range(batch_size):
prog_bar.update()
return results
def single_gpu_test(model,
data_loader,
show=False,
out_dir=None,
show_score_thr=0.3):
model.eval()
results = []
dataset = data_loader.dataset
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
results.append(result)
if show or out_dir:
if not os.path.exists(out_dir):
os.mkdir(out_dir)
img_tensor = data['img'][0]
img_metas = data['img_metas'][0].data[0]
imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg'])
assert len(imgs) == len(img_metas)
for img, img_meta in zip(imgs, img_metas):
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir, img_meta['filename'].split('/')[-1])
else:
out_file = None
model.module.show_result(
img_show,
result,
show=show,
out_file=out_file,
score_thr=show_score_thr)
batch_size = data['img'][0].size(0)
for _ in range(batch_size):
prog_bar.update()
return results
def show_result(self, data, result, img_norm_cfg, classes):
img_tensor = data['img']
img_norm_cfg_255 = copy.deepcopy(img_norm_cfg)
img_norm_cfg_255['mean'] = [x * 255. for x in img_norm_cfg['mean']]
img_norm_cfg_255['std'] = [x * 255. for x in img_norm_cfg['std']]
img = tensor2imgs(img_tensor, **img_norm_cfg_255)[0]
img = cv2.resize(img, (256, 256))
labels_list, scores_list = result
labels = labels_list[0]
scores = scores_list[0]
for i in range(len(labels)):
idx = labels[i]
img = cv2.putText(img, classes[idx] + ': %.2f' % (scores[i]),
(20, 20 + i * 15), cv2.FONT_HERSHEY_SIMPLEX, 0.6,
(0, 0, 255))
cv2.imshow('img', img)
cv2.waitKey(0)
def forward_train(self,
img_z,
img_x,
img_meta_z,
img_meta_x,
gt_bboxes_z=None,
gt_bboxes_x=None,
gt_bboxes_ignore=None):
if self.train_cfg.rpn.get('debug', False):
self.rpn_head.debug_imgs = tensor2imgs(img_x)
z = self.extract_feat(img_z)
x = self.extract_feat(img_x)
losses = {}
num = 0. # total number of instances
for x_ij, i, j in self.rpn_modulator(z, x, gt_bboxes_z):
# select the j-th bbox of the i-th image
gt_bboxes_ij = gt_bboxes_x[i:i + 1]
gt_bboxes_ij[0] = gt_bboxes_ij[0][j:j + 1]
# RPN forward and losses
rpn_outs = self.rpn_head(x_ij)
rpn_loss_inputs = rpn_outs + (
gt_bboxes_ij, img_meta_x[i:i + 1], self.train_cfg.rpn)
losses_ij = self.rpn_head.loss(
*rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore)
# update with RPN losses
for k, v in losses_ij.items():
if k in losses:
if isinstance(v, (tuple, list)):
for o in range(len(v)):
losses[k][o] += v[o]
else:
losses[k] += v
else:
losses[k] = v
# update total instance number
num += 1.
# average the losses over instances
for k, v in losses.items():
for o in range(len(v)):
losses[k][o] /= num
return losses
