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