def main(): parser = ArgumentParser() parser.add_argument('--img', default="demo.jpg", help='Image file') parser.add_argument( '--config', # default="/home/jaychen/Desktop/PycharmProjects/2020.12.10/mmdetection_2.7/configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py", default= "/home/jaychen/Desktop/PycharmProjects/2020.12.10/mmdetection_2.7/configs/rpn/rpn_r50_fpn_2x_coco.py", help='Config file') parser.add_argument( '--checkpoint', # default="/home/jaychen/Desktop/MODELWEIGHTS/retinanet_r50_caffe_fpn_1x_coco_20200531-f11027c5.pth", default="../checkpoints/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth", help='Checkpoint file') parser.add_argument('--device', default='cuda:0', help='Device used for inference') parser.add_argument('--score-thr', type=float, default=0.3, help='bbox score threshold') args = parser.parse_args() # build the model from a config file and a checkpoint file model = init_detector(args.config, args.checkpoint, device=args.device) # test a single image result = inference_detector(model, args.img) # show the results # show_result_pyplot(model, args.img, result, score_thr=args.score_thr) # show RPN result img_show = mmcv.imread(args.img) mmcv.imshow_bboxes(img_show, result, top_k=20)
def visualize_gt_bboxes(self, imgs, gt_bboxes, img_meta): gt_bboxes_np = gt_bboxes[0].cpu().numpy() for bbox in gt_bboxes_np: for slice_num in range(int(bbox[4]), int(bbox[5])): img = tensor2img3D(imgs, slice_num=slice_num) filename = 'tests/iter_{}_img_id_{}_slice_{}.png'.format(self.iteration, img_meta[0]['image_id'], slice_num) mmcv.imshow_bboxes(img, np.array([bbox]), 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=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_result(self, data, result, top_k=20, **kwargs): """Show RPN proposals on the image. Args: data (str or np.ndarray): Image filename or loaded image. result (Tensor or tuple): The results to draw over `img` bbox_result or (bbox_result, segm_result). top_k (int): Plot the first k bboxes only if set positive. Default: 20 Returns: np.ndarray: The image with bboxes drawn on it. """ mmcv.imshow_bboxes(data, result, top_k=top_k)
def filter(dets): det_bboxes = np.vstack(dets) adj = np.zeros((len(det_bboxes), len(det_bboxes)), int) for i in range(len(det_bboxes)): for j in range(i): boxA = det_bboxes[i] boxB = det_bboxes[j] xA = max(boxA[0], boxB[0]) yA = max(boxA[1], boxB[1]) xB = min(boxA[2], boxB[2]) yB = min(boxA[3], boxB[3]) # compute the area of intersection rectangle interArea = max(0, xB - xA) * max(0, yB - yA) boxAArea = (boxA[2] - boxA[0] + 1) * (boxA[3] - boxA[1] + 1) boxBArea = (boxB[2] - boxB[0] + 1) * (boxB[3] - boxB[1] + 1) iou = interArea / float(boxAArea + boxBArea - interArea) if (iou > 0.02): adj[i][j] = adj[j][i] = 1 print(adj) n = len(det_bboxes) ConSubSets = [] for i in range(len(det_bboxes)): bset = [] for j in range(len(det_bboxes)): if adj[i][j] == 0: bset.append(det_bboxes[j]) ConSubSets.append(np.asarray(bset)) alla, alls, fscr = [], [], [] for sl in ConSubSets: areas = sum([(box[2] - box[0]) * (box[3] - box[1]) for box in sl]) / 500000.0 alla.append(areas) # print(areas) bxnd = np.asarray(sl) scores = bxnd[:, -1] ms = np.mean(scores) # print(ms) alls.append(ms) fscr.append(np.mean(areas + ms)) mmcv.imshow_bboxes('demo/minival/PMC4982048_00021.jpg', bxnd) idx = fscr.index(max(fscr)) mmcv.imshow_bboxes('demo/minival/PMC4982048_00021.jpg', np.asarray(ConSubSets[idx]))
def show_result(self, img, result, color='green', thickness=1, show=False, win_name='', wait_time=0, out_file=None, **kwargs): """Visualize tracking results. Args: img (str or ndarray): The image to be displayed. result (dict): Tracking result. The value of key 'track_results' is ndarray with shape (5, ) in [tl_x, tl_y, br_x, br_y, score] format. color (str or tuple or Color, optional): color of bbox. Defaults to green. thickness (int, optional): Thickness of lines. Defaults to 1. show (bool, optional): Whether to show the image. Defaults to False. win_name (str, optional): The window name. Defaults to ''. wait_time (int, optional): Value of waitKey param. Defaults to 0. out_file (str, optional): The filename to write the image. Defaults to None. Returns: ndarray: Visualized image. """ assert isinstance(result, dict) track_result = result.get('track_results', None) assert track_result.ndim == 1 assert track_result.shape[0] == 5 track_bbox = track_result[:4] mmcv.imshow_bboxes( img, track_bbox[np.newaxis, :], colors=color, thickness=thickness, show=show, win_name=win_name, wait_time=wait_time, out_file=out_file) return img
def show_result(self, data): """Show the init proposals in EmbeddingRPN. Args: data (dict): Dict contains image and corresponding meta information. """ img_tensor = data['img'][0] img_metas = data['img_metas'][0].data[0] imgs = tensor2imgs(img_tensor, **img_metas[0]['img_norm_cfg']) proposals, _ = self._decode_init_proposals(data['img'], data['img_metas']) 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, proposals)
def tensor2img3DNPrint(tensor, slice_num=85, bboxes=np.array([[0, 0, 0, 0]]), mean=(123.675, 116.28, 103.53), std=(58.395, 57.12, 57.375), to_rgb=True): mean = np.array(mean, dtype=np.float32) std = np.array(std, dtype=np.float32) # get the first image imgs = tensor[0, ...].cpu().numpy().transpose(2, 3, 1, 0) # get the first slice img = imgs[:, :, slice_num, :] img = mmcv.imdenormalize(img, mean, std, to_bgr=False) img = np.ascontiguousarray(img) mmcv.imshow_bboxes(img, bboxes) return img
def test_imshow(self, debug=True): """ Usage: export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 export TIME_STR=1 export PYTHONPATH=./exp:./stylegan2-pytorch:./ python -c "from exp.tests.test_styleganv2 import Testing_stylegan2;\ Testing_stylegan2().test_train_ffhq_128()" :return: """ if 'CUDA_VISIBLE_DEVICES' not in os.environ: os.environ['CUDA_VISIBLE_DEVICES'] = '0' if 'TIME_STR' not in os.environ: os.environ['TIME_STR'] = '0' if utils.is_debugging() else '0' from template_lib.v2.config_cfgnode.argparser import \ (get_command_and_outdir, setup_outdir_and_yaml, get_append_cmd_str, start_cmd_run) tl_opts = ' '.join(sys.argv[sys.argv.index('--tl_opts') + 1:]) if '--tl_opts' in sys.argv else '' print(f'tl_opts:\n {tl_opts}') command, outdir = get_command_and_outdir( self, func_name=sys._getframe().f_code.co_name, file=__file__) argv_str = f""" --tl_config_file none --tl_command none --tl_outdir {outdir} --tl_opts {tl_opts} """ args, cfg = setup_outdir_and_yaml(argv_str, return_cfg=True) n_gpus = len(os.environ['CUDA_VISIBLE_DEVICES'].split(',')) import mmcv import numpy as np img_path = "template_lib/datasets/images/zebra_GT_target_origin.png" mmcv.imshow(img_path) # show image with bounding boxes img = np.random.rand(100, 100, 3) bboxes = np.array([[0, 0, 50, 50], [20, 20, 60, 60]]) mmcv.imshow_bboxes(img, bboxes) pass
def show_result(self, data, result, top_k=20, **kwargs): """Show RPN proposals on the image. Args: data (str or np.ndarray): Image filename or loaded image. result (Tensor or tuple): The results to draw over `img` bbox_result or (bbox_result, segm_result). top_k (int): Plot the first k bboxes only if set positive. Default: 20 Returns: np.ndarray: The image with bboxes drawn on it. """ if kwargs is not None: kwargs.pop('score_thr', None) kwargs.pop('text_color', None) kwargs['colors'] = kwargs.pop('bbox_color', 'green') mmcv.imshow_bboxes(data, result, top_k=top_k, **kwargs)
def visualize_anchor_boxes(self, imgs, cls_scores, img_metas, slice_num=45, top_k=None, shuffle=False): featmap_sizes = [featmap.size()[-3:] for featmap in cls_scores] assert len(featmap_sizes) == len(self.anchor_generators) anchor_list, valid_flag_list = self.get_anchors( featmap_sizes, img_metas) img = tensor2img3D(imgs, slice_num=slice_num) anchors = [] unique_set = set() for bboxes in anchor_list[0]: bboxes = bboxes.cpu().numpy() for bbox in bboxes: # select each aspect ratio bounding box in the middle of an image # if bbox[0] >= 100 and bbox[0] <= 400 and bbox[2] >= 100 and bbox[2] <= 400 and \ # bbox[1] >= 150 and bbox[1] <= 450 and bbox[3] >= 150 and bbox[3] <= 450 and \ # slice_num >= bbox[4] and slice_num <= bbox[5] and (bbox[5] - bbox[4]) not in unique_set: # unique_set.add(bbox[5] - bbox[4]) # anchors.append([bbox[0], bbox[1], bbox[2], bbox[3]]) # Get all anchors in the middle of the image if bbox[0] >= 100 and bbox[0] <= 400 and bbox[2] >= 100 and bbox[2] <= 400 and \ bbox[1] >= 150 and bbox[1] <= 450 and bbox[3] >= 150 and bbox[3] <= 450 and \ slice_num >= bbox[4] and slice_num <= bbox[5] and (bbox[2] - bbox[0]) not in unique_set: anchors.append([bbox[0], bbox[1], bbox[2], bbox[3]]) print(unique_set) breakpoint() if shuffle is True: while True: random.shuffle(anchors) mmcv.imshow_bboxes(img, np.array(anchors), top_k=20) elif top_k is None: mmcv.imshow_bboxes(img, np.array(anchors)) else: mmcv.imshow_bboxes(img, np.array(anchors), top_k=top_k) breakpoint()
def show_result(self, result, img=None, skeleton=None, kpt_score_thr=0.3, radius=8, bbox_color='green', thickness=2, pose_kpt_color=None, pose_link_color=None, vis_height=400, num_instances=-1, axis_azimuth=-115, win_name='', show=False, wait_time=0, out_file=None): """Visualize 3D pose estimation results. Args: result (list[dict]): The pose estimation results containing: - "keypoints_3d" ([K,4]): 3D keypoints - "keypoints" ([K,3] or [T,K,3]): Optional for visualizing 2D inputs. If a sequence is given, only the last frame will be used for visualization - "bbox" ([4,] or [T,4]): Optional for visualizing 2D inputs - "title" (str): title for the subplot img (str or Tensor): Optional. The image to visualize 2D inputs on. skeleton (list of [idx_i,idx_j]): Skeleton described by a list of links, each is a pair of joint indices. kpt_score_thr (float, optional): Minimum score of keypoints to be shown. Default: 0.3. radius (int): Radius of circles. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. thickness (int): Thickness of lines. pose_kpt_color (np.array[Nx3]`): Color of N keypoints. If None, do not draw keypoints. pose_link_color (np.array[Mx3]): Color of M limbs. If None, do not draw limbs. vis_height (int): The image height of the visualization. The width will be N*vis_height depending on the number of visualized items. num_instances (int): Number of instances to be shown in 3D. If smaller than 0, all the instances in the pose_result will be shown. Otherwise, pad or truncate the pose_result to a length of num_instances. axis_azimuth (float): axis azimuth angle for 3D visualizations. win_name (str): The window name. show (bool): Whether to show the image. Default: False. wait_time (int): Value of waitKey param. Default: 0. out_file (str or None): The filename to write the image. Default: None. Returns: Tensor: Visualized img, only if not `show` or `out_file`. """ if num_instances < 0: assert len(result) > 0 result = sorted(result, key=lambda x: x.get('track_id', 0)) # draw image and 2d poses if img is not None: img = mmcv.imread(img) bbox_result = [] pose_2d = [] for res in result: if 'bbox' in res: bbox = np.array(res['bbox']) if bbox.ndim != 1: assert bbox.ndim == 2 bbox = bbox[-1] # Get bbox from the last frame bbox_result.append(bbox) if 'keypoints' in res: kpts = np.array(res['keypoints']) if kpts.ndim != 2: assert kpts.ndim == 3 kpts = kpts[-1] # Get 2D keypoints from the last frame pose_2d.append(kpts) if len(bbox_result) > 0: bboxes = np.vstack(bbox_result) mmcv.imshow_bboxes(img, bboxes, colors=bbox_color, top_k=-1, thickness=2, show=False) if len(pose_2d) > 0: imshow_keypoints(img, pose_2d, skeleton, kpt_score_thr=kpt_score_thr, pose_kpt_color=pose_kpt_color, pose_link_color=pose_link_color, radius=radius, thickness=thickness) img = mmcv.imrescale(img, scale=vis_height / img.shape[0]) img_vis = imshow_keypoints_3d(result, img, skeleton, pose_kpt_color, pose_link_color, vis_height, axis_limit=300, axis_azimuth=axis_azimuth, axis_elev=15, kpt_score_thr=kpt_score_thr, num_instances=num_instances) if show: mmcv.visualization.imshow(img_vis, win_name, wait_time) if out_file is not None: mmcv.imwrite(img_vis, out_file) return img_vis
def show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, bbox_color='green', pose_kpt_color=None, pose_limb_color=None, radius=4, text_color=(255, 0, 0), thickness=1, font_scale=0.5, win_name='', show=False, show_keypoint_weight=False, wait_time=0, out_file=None): """Draw `result` over `img`. Args: img (str or Tensor): The image to be displayed. result (list[dict]): The results to draw over `img` (bbox_result, pose_result). kpt_score_thr (float, optional): Minimum score of keypoints to be shown. Default: 0.3. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. pose_kpt_color (np.array[Nx3]`): Color of N keypoints. If None, do not draw keypoints. pose_limb_color (np.array[Mx3]): Color of M limbs. If None, do not draw limbs. text_color (str or tuple or :obj:`Color`): Color of texts. thickness (int): Thickness of lines. font_scale (float): Font scales of texts. win_name (str): The window name. wait_time (int): Value of waitKey param. Default: 0. out_file (str or None): The filename to write the image. Default: None. Returns: Tensor: Visualized img, only if not `show` or `out_file`. """ img = mmcv.imread(img) img = img.copy() img_h, img_w, _ = img.shape bbox_result = [] pose_result = [] for res in result: bbox_result.append(res['bbox']) pose_result.append(res['keypoints']) if len(bbox_result) > 0: bboxes = np.vstack(bbox_result) # draw bounding boxes mmcv.imshow_bboxes( img, bboxes, colors=bbox_color, top_k=-1, thickness=thickness, show=False, win_name=win_name, wait_time=wait_time, out_file=None) for _, kpts in enumerate(pose_result): # draw each point on image if pose_kpt_color is not None: assert len(pose_kpt_color) == len(kpts) for kid, kpt in enumerate(kpts): x_coord, y_coord, kpt_score = int(kpt[0]), int( kpt[1]), kpt[2] if kpt_score > kpt_score_thr: if show_keypoint_weight: img_copy = img.copy() r, g, b = pose_kpt_color[kid] cv2.circle(img_copy, (int(x_coord), int(y_coord)), radius, (int(r), int(g), int(b)), -1) transparency = max(0, min(1, kpt_score)) cv2.addWeighted( img_copy, transparency, img, 1 - transparency, 0, dst=img) else: r, g, b = pose_kpt_color[kid] cv2.circle(img, (int(x_coord), int(y_coord)), radius, (int(r), int(g), int(b)), -1) # draw limbs if skeleton is not None and pose_limb_color is not None: assert len(pose_limb_color) == len(skeleton) for sk_id, sk in enumerate(skeleton): pos1 = (int(kpts[sk[0] - 1, 0]), int(kpts[sk[0] - 1, 1])) pos2 = (int(kpts[sk[1] - 1, 0]), int(kpts[sk[1] - 1, 1])) if (pos1[0] > 0 and pos1[0] < img_w and pos1[1] > 0 and pos1[1] < img_h and pos2[0] > 0 and pos2[0] < img_w and pos2[1] > 0 and pos2[1] < img_h and kpts[sk[0] - 1, 2] > kpt_score_thr and kpts[sk[1] - 1, 2] > kpt_score_thr): r, g, b = pose_limb_color[sk_id] if show_keypoint_weight: img_copy = img.copy() X = (pos1[0], pos2[0]) Y = (pos1[1], pos2[1]) mX = np.mean(X) mY = np.mean(Y) length = ((Y[0] - Y[1])**2 + (X[0] - X[1])**2)**0.5 angle = math.degrees( math.atan2(Y[0] - Y[1], X[0] - X[1])) stickwidth = 2 polygon = cv2.ellipse2Poly( (int(mX), int(mY)), (int(length / 2), int(stickwidth)), int(angle), 0, 360, 1) cv2.fillConvexPoly(img_copy, polygon, (int(r), int(g), int(b))) transparency = max( 0, min( 1, 0.5 * (kpts[sk[0] - 1, 2] + kpts[sk[1] - 1, 2]))) cv2.addWeighted( img_copy, transparency, img, 1 - transparency, 0, dst=img) else: cv2.line( img, pos1, pos2, (int(r), int(g), int(b)), thickness=thickness) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
def imshow_bboxes_ref(img, bboxes0, bboxes1): bboxes = np.concatenate([bboxes0, bboxes1], 0) n0 = bboxes0.shape[0] n1 = bboxes1.shape[0] colors = ['red'] * n0 + ['green'] * n1 mmcv.imshow_bboxes(img, bboxes, colors)
def imshow_bboxes(img, bboxes, labels=None, colors='green', text_color='white', thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes with labels (optional) on an image. This is a wrapper of mmcv.imshow_bboxes. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): ndarray of shape (k, 4), each row is a bbox in format [x1, y1, x2, y2]. labels (str or list[str], optional): labels of each bbox. colors (list[str or tuple or :obj:`Color`]): A list of colors. text_color (str or tuple or :obj:`Color`): Color of texts. thickness (int): Thickness of lines. font_scale (float): Font scales of texts. show (bool): Whether to show the image. win_name (str): The window name. wait_time (int): Value of waitKey param. out_file (str, optional): The filename to write the image. Returns: ndarray: The image with bboxes drawn on it. """ # adapt to mmcv.imshow_bboxes input format bboxes = np.split(bboxes, bboxes.shape[0], axis=0) if bboxes.shape[0] > 0 else [] if not isinstance(colors, list): colors = [colors for _ in range(len(bboxes))] colors = [mmcv.color_val(c) for c in colors] assert len(bboxes) == len(colors) img = mmcv.imshow_bboxes(img, bboxes, colors, top_k=-1, thickness=thickness, show=False, out_file=None) if labels is not None: if not isinstance(labels, list): labels = [labels for _ in range(len(bboxes))] assert len(labels) == len(bboxes) for bbox, label, color in zip(bboxes, labels, colors): bbox_int = bbox[0, :4].astype(np.int32) # roughly estimate the proper font size text_size, text_baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_DUPLEX, font_scale, thickness) text_x1 = bbox_int[0] text_y1 = max(0, bbox_int[1] - text_size[1] - text_baseline) text_x2 = bbox_int[0] + text_size[0] text_y2 = text_y1 + text_size[1] + text_baseline cv2.rectangle(img, (text_x1, text_y1), (text_x2, text_y2), color, cv2.FILLED) cv2.putText(img, label, (text_x1, text_y2 - text_baseline), cv2.FONT_HERSHEY_DUPLEX, font_scale, mmcv.color_val(text_color), thickness) if show: mmcv.imshow(img, win_name, wait_time) if out_file is not None: mmcv.imwrite(img, out_file) return img
def show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, bbox_color='green', pose_kpt_color=None, pose_limb_color=None, text_color=(255, 0, 0), radius=4, thickness=1, font_scale=0.5, win_name='', show=False, show_keypoint_weight=False, wait_time=0, out_file=None): """Draw `result` over `img`. Args: img (str or Tensor): The image to be displayed. result (list[dict]): The results to draw over `img` (bbox_result, pose_result). skeleton (list[list]): The connection of keypoints. kpt_score_thr (float, optional): Minimum score of keypoints to be shown. Default: 0.3. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. pose_kpt_color (np.array[Nx3]`): Color of N keypoints. If None, do not draw keypoints. pose_limb_color (np.array[Mx3]): Color of M limbs. If None, do not draw limbs. text_color (str or tuple or :obj:`Color`): Color of texts. radius (int): Radius of circles. thickness (int): Thickness of lines. font_scale (float): Font scales of texts. win_name (str): The window name. show (bool): Whether to show the image. Default: False. show_keypoint_weight (bool): Whether to change the transparency using the predicted confidence scores of keypoints. wait_time (int): Value of waitKey param. Default: 0. out_file (str or None): The filename to write the image. Default: None. Returns: Tensor: Visualized img, only if not `show` or `out_file`. """ img = mmcv.imread(img) img = img.copy() img_h, img_w, _ = img.shape bbox_result = [] pose_result = [] for res in result: bbox_result.append(res['bbox']) pose_result.append(res['keypoints']) if len(bbox_result) > 0: bboxes = np.vstack(bbox_result) # draw bounding boxes mmcv.imshow_bboxes(img, bboxes, colors=bbox_color, top_k=-1, thickness=thickness, show=False) imshow_keypoints(img, pose_result, skeleton, kpt_score_thr, pose_kpt_color, pose_limb_color, radius, thickness) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
def add_bboxs_to_img(img_path: str, xml_path: str, out_path: str): bboxs = get_bboxs_from_xml(xml_path) mmcv.imshow_bboxes(img_path, bboxs, show=False, out_file=out_path)
def crop4patches(img_prefix, img_writen, istrain=True): if not os.path.exists(img_writen + 'annotations/'): os.makedirs(img_writen + 'annotations/') if not os.path.exists(img_writen + 'images/'): os.makedirs(img_writen + 'images/') img_infos = [] img_file = img_prefix + 'images/' all_imgs_files = os.listdir(img_file) for img_file in all_imgs_files: img_id = img_file.split('.')[0] anno_name = 'annotations/{}.txt'.format(img_id) img_name = 'images/{}.jpg'.format(img_id) #p rint(filename) print("dealing with {}".format(img_name)) img_path = osp.join(img_prefix, img_name) anno_path = osp.join(img_prefix, anno_name) img = cv2.imread(img_path) h, w, c = img.shape print("h {}".format(h)) print("w {}".format(w)) patch_width = int(w) // 2 patch_height = int(h) // 2 bboxes = [] bboxes.append(np.array([0, 0, patch_width, patch_height])) bboxes.append(np.array([0, patch_height, patch_width, h])) bboxes.append(np.array([patch_width, 0, w, patch_height])) bboxes.append(np.array([patch_width, patch_height, w, h])) padw = (w - patch_width) // 2 padh = (h - patch_height) // 2 if istrain: bboxes.append(np.array([padw, padh, w - padw, h - padh])) bboxes = np.array(bboxes) img_patches = mmcv.imcrop(img, bboxes, scale=1.0) for jj in range(len(img_patches)): if istrain: assert (len(img_patches)) == 5 else: assert (len(img_patches)) == 4 cv2.imwrite(img_writen + 'images/{}_{}.jpg'.format(img_id, jj + 1), img_patches[jj]) with open(anno_path, 'r') as ann: note = ann.readlines() # 计算中心 patch的标注 if istrain: for item in note: values_str = item.split(',') #list() bbox_left,bbox_top,bbox_width,bbox_height,score,object_category,\ truncation,occulusion = int(values_str[0]),int(values_str[1]),\ int(values_str[2]),int(values_str[3]),int(values_str[4]),int(values_str[5]),\ int(values_str[6]),int(values_str[7]) # in central patch if bbox_left > padw and bbox_top > padh and bbox_left < w - padw and bbox_top < h - padh: if bbox_left + bbox_width > w - padw or bbox_top + bbox_height > h - padh: if bbox_iou((bbox_left,bbox_top,bbox_left+bbox_width,bbox_top+bbox_height),\ (bbox_left,bbox_top,min(w-padw,bbox_left+bbox_width),min(h-padh,bbox_top+bbox_height))) > 0.5: message = str(bbox_left-padw)+','+str(bbox_top-padh)+','+str(min(w-padw,bbox_left+bbox_width)-bbox_left)+','+str(min(h-padh,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(1)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 5) save_newanno(message, path) continue else: continue else: message = str(bbox_left-padw)+','+str(bbox_top-padh)+','+str(min(w-padw,bbox_left+bbox_width)-bbox_left)+','+str(min(h-padh,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(truncation)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 5) #print("5loc {}".format(message)) save_newanno(message, path) continue for item in note: values_str = item.split(',') #list() bbox_left,bbox_top,bbox_width,bbox_height,score,object_category,\ truncation,occulusion = int(values_str[0]),int(values_str[1]),\ int(values_str[2]),int(values_str[3]),int(values_str[4]),int(values_str[5]),\ int(values_str[6]),int(values_str[7]) if bbox_left < patch_width and bbox_top < patch_height: # zuoshang if bbox_left + bbox_width > patch_width or bbox_top + bbox_height > patch_height: # outline if bbox_iou((bbox_left,bbox_top,bbox_left+bbox_width,bbox_top+bbox_height),\ (bbox_left,bbox_top,min(patch_width,bbox_left+bbox_width),min(patch_height,bbox_top+bbox_height))) > 0.5: #save message = str(bbox_left-0)+','+str(bbox_top-0)+','+str(min(patch_width,bbox_left+bbox_width)-bbox_left)+','+str(min(patch_height,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(1)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 1) save_newanno(message, path) continue else: # dont save continue else: # 完整直接save message = str(bbox_left-0)+','+str(bbox_top-0)+','+str(min(patch_width,bbox_left+bbox_width)-bbox_left)+','+str(min(patch_height,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(truncation)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 1) save_newanno(message, path) #print("1loc {}".format(message)) continue #zuoxia if bbox_left < patch_width and bbox_top >= patch_height: if bbox_top + bbox_height > h: # 原本标注错误 raise IOError if bbox_left + bbox_width > patch_width: # outline if bbox_iou((bbox_left,bbox_top,bbox_left+bbox_width,bbox_top+bbox_height),\ (bbox_left,bbox_top,min(patch_width,bbox_left+bbox_width),min(patch_height,bbox_top+bbox_height))) > 0.5: #save message = str(bbox_left-0)+','+str(bbox_top-patch_height)+','+str(min(patch_width,bbox_left+bbox_width)-bbox_left)+','+str(min(h,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(1)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 2) save_newanno(message, path) continue else: # dont save continue else: #save message = str(bbox_left-0)+','+str(bbox_top-patch_height)+','+str(min(patch_width,bbox_left+bbox_width)-bbox_left)+','+str(min(h,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(truncation)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 2) save_newanno(message, path) #print("2loc {}".format(message)) continue #youshang if bbox_left >= patch_width and bbox_top < patch_height: if bbox_left + bbox_width > w: raise IOError if bbox_top + bbox_height > patch_height: # outline if bbox_iou((bbox_left,bbox_top,bbox_left+bbox_width,bbox_top+bbox_height),\ (bbox_left,bbox_top,min(patch_width,bbox_left+bbox_width),min(patch_height,bbox_top+bbox_height))) > 0.5: #save message = str(bbox_left-patch_width)+','+str(bbox_top-0)+','+str(min(w,bbox_left+bbox_width)-bbox_left)+','+str(min(patch_height,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(1)+','+str(occulusion)# must trucncation path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 3) save_newanno(message, path) continue else: # dont save continue else: #save message = str(bbox_left-patch_width)+','+str(bbox_top-0)+','+str(min(w,bbox_left+bbox_width)-bbox_left)+','+str(min(patch_height,bbox_top+bbox_height)-bbox_top)\ +','+str(score)+','+str(object_category)+','+str(truncation)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 3) save_newanno(message, path) #print("3loc {}".format(message)) continue # youxia if bbox_left >= patch_width and bbox_top >= patch_height: if bbox_left + bbox_width > w or bbox_height + bbox_top > h: raise IOError # 第四个区域不会有 outline message = str(bbox_left-patch_width)+','+str(bbox_top-patch_height)+','+str(bbox_width)+','+str(bbox_height)\ +','+str(score)+','+str(object_category)+','+str(truncation)+','+str(occulusion) path = img_writen + 'annotations/{}_{}.txt'.format( img_id, 4) save_newanno(message, path) #print("4loc {}".format(message)) continue #check if the image has no annotaion , delet it for jj in range(len(img_patches)): if istrain: assert (len(img_patches)) == 5 else: assert (len(img_patches)) == 4 if not os.path.exists( img_writen + 'annotations/{}_{}.txt'.format(img_id, jj + 1)): os.remove(img_writen + 'images/{}_{}.jpg'.format(img_id, jj + 1)) #path = img_writen+'annotations/{}_{}.txt'.format(img_id,jj+1) #with open(path,'w') as ann: # 追加模式 # pass #print("empty {}".format('annotations/{}_{}.jpg'.format(img_id,jj+1))) new_list = os.listdir(img_writen + 'images/') new_list_show = [] new_list_show.extend(new_list[:100]) new_list_show.extend(new_list[500:600]) for ii, item in enumerate(new_list_show): showimg = cv2.imread(img_writen + 'images/' + item) id = item.split('.')[0] annotation = img_writen + 'annotations/' + id + '.txt' #if not os.path.exists(annotation): # continue with open(annotation, 'r') as ann: note = ann.readlines() bboxes = [] for jj in note: values_str = jj.split(',') #list() bbox_left,bbox_top,bbox_width,bbox_height,score,object_category,\ truncation,occulusion = int(values_str[0]),int(values_str[1]),\ int(values_str[2]),int(values_str[3]),int(values_str[4]),int(values_str[5]),\ int(values_str[6]),int(values_str[7]) bboxes.append( np.array([ bbox_left, bbox_top, bbox_left + bbox_width, bbox_top + bbox_height ])) bboxes = np.array(bboxes) print('/home/share2/VisDrone2019/vispatch/' + item) if istrain: mmcv.imshow_bboxes( showimg, bboxes, show=False, out_file='/home/share2/VisDrone2019/TASK1/trainpatch/' + item) else: mmcv.imshow_bboxes( showimg, bboxes, show=False, out_file='/home/share2/VisDrone2019/TASK1/valpatch/' + item)
def show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, bbox_color='green', pose_kpt_color=(255, 0, 0), pose_limb_color=None, radius=4, text_color=(255, 0, 0), thickness=1, font_scale=0.5, win_name='', show=False, wait_time=0, out_file=None): """Draw `result` over `img`. Args: img (str or Tensor): The image to be displayed. result (list[dict]): The results to draw over `img` (bbox_result, pose_result). kpt_score_thr (float, optional): Minimum score of keypoints to be shown. Default: 0.3. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. pose_kpt_color (str or tuple or :obj:`Color`): Color of keypoints. pose_limb_color (str or tuple or :obj:`Color`): Color of limbs. text_color (str or tuple or :obj:`Color`): Color of texts. thickness (int): Thickness of lines. font_scale (float): Font scales of texts. win_name (str): The window name. wait_time (int): Value of waitKey param. Default: 0. show (bool): Whether to show the image. Default: False. out_file (str or None): The filename to write the image. Default: None. Returns: Tensor: Img: Only if not `show` or `out_file`. """ img = mmcv.imread(img) img = img.copy() img_h, img_w, _ = img.shape bbox_result = [] pose_result = [] for res in result: bbox_result.append(res['bbox']) pose_result.append(res['keypoints']) bboxes = np.vstack(bbox_result) # if out_file specified, do not show image in window if out_file is not None: show = False # draw bounding boxes mmcv.imshow_bboxes(img, bboxes, colors=bbox_color, top_k=-1, thickness=thickness, show=False, win_name=win_name, wait_time=wait_time, out_file=None) for person_id, kpts in enumerate(pose_result): # draw each point on image for kid, kpt in enumerate(kpts): x_coord, y_coord, kpt_score = int(kpt[0]), int(kpt[1]), kpt[2] if kpt_score > kpt_score_thr: cv2.circle(img, (x_coord, y_coord), radius, pose_kpt_color, thickness) cv2.putText(img, f'{kid}', (x_coord, y_coord - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color) # draw limbs if skeleton is not None: for sk in skeleton: pos1 = (int(kpts[sk[0] - 1, 0]), int(kpts[sk[0] - 1, 1])) pos2 = (int(kpts[sk[1] - 1, 0]), int(kpts[sk[1] - 1, 1])) if pos1[0] > 0 and pos1[0] < img_w \ and pos1[1] > 0 and pos1[1] < img_h \ and pos2[0] > 0 and pos2[0] < img_w \ and pos2[1] > 0 and pos2[1] < img_h \ and kpts[sk[0] - 1, 2] > kpt_score_thr \ and kpts[sk[1] - 1, 2] > kpt_score_thr: cv2.line(img, pos1, pos2, pose_kpt_color, 2, 8) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) if not (show or out_file): warnings.warn('show==False and out_file is not specified, only ' 'result image will be returned') return img
# -*- coding: utf-8 -* - ''' MMCV显示图片相关 参考:https://mmcv.readthedocs.io/en/latest/visualization.html ''' import mmcv import numpy as np # 显示图片文件 mmcv.imshow("cluo.jpg") # 显示numpy数组格式的图片 img = np.random.rand(100,100,3)*255 mmcv.imshow(img) # 显示图片并伴有bounding box img = np.random.rand(100,100,3)*255 bboxes = np.array([[0,0,50,50],[20,20,60,60]]) mmcv.imshow_bboxes(img,bboxes,colors=["red"],show=False,out_file="cluo_bbox.jpg") # 显示图片并伴有bounding box以及框的标题 labels = np.array([1,3]) classes = ["类别0","类别1","类别2","类别3"] mmcv.imshow_det_bboxes(img,bboxes,labels,classes,bbox_color="green",text_color="blue",out_file="cluo_bbox_label.jpg")
def show_result(self, result, img, show=False, out_file=None, win_name='', wait_time=0, bbox_color='green', mesh_color=(76, 76, 204), **kwargs): """Visualize 3D mesh estimation results. Args: result (list[dict]): The mesh estimation results containing: - "bbox" (ndarray[4]): instance bounding bbox - "center" (ndarray[2]): bbox center - "scale" (ndarray[2]): bbox scale - "keypoints_3d" (ndarray[K,3]): predicted 3D keypoints - "camera" (ndarray[3]): camera parameters - "vertices" (ndarray[V, 3]): predicted 3D vertices - "faces" (ndarray[F, 3]): mesh faces img (str or Tensor): Optional. The image to visualize 2D inputs on. win_name (str): The window name. show (bool): Whether to show the image. Default: False. wait_time (int): Value of waitKey param. Default: 0. out_file (str or None): The filename to write the image. Default: None. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. mesh_color (str or tuple or :obj:`Color`): Color of mesh surface. Returns: ndarray: Visualized img, only if not `show` or `out_file`. """ if img is not None: img = mmcv.imread(img) focal_length = self.loss_mesh.focal_length H, W, C = img.shape img_center = np.array([[0.5 * W], [0.5 * H]]) # show bounding boxes bboxes = [res['bbox'] for res in result] bboxes = np.vstack(bboxes) mmcv.imshow_bboxes(img, bboxes, colors=bbox_color, top_k=-1, thickness=2, show=False) vertex_list = [] face_list = [] for res in result: vertices = res['vertices'] faces = res['faces'] camera = res['camera'] camera_center = res['center'] scale = res['scale'] # predicted vertices are in root-relative space, # we need to translate them to camera space. translation = np.array([ camera[1], camera[2], 2 * focal_length / (scale[0] * 200.0 * camera[0] + 1e-9) ]) mean_depth = vertices[:, -1].mean() + translation[-1] translation[:2] += (camera_center - img_center[:, 0]) / focal_length * mean_depth vertices += translation[None, :] vertex_list.append(vertices) face_list.append(faces) # render from front view img_vis = imshow_mesh_3d(img, vertex_list, face_list, img_center, [focal_length, focal_length], colors=mesh_color) # render from side view # rotate mesh vertices R = cv2.Rodrigues(np.array([0, np.radians(90.), 0]))[0] rot_vertex_list = [np.dot(vert, R) for vert in vertex_list] # get the 3D bbox containing all meshes rot_vertices = np.concatenate(rot_vertex_list, axis=0) min_corner = rot_vertices.min(0) max_corner = rot_vertices.max(0) center_3d = 0.5 * (min_corner + max_corner) ratio = 0.8 bbox3d_size = max_corner - min_corner # set appropriate translation to make all meshes appear in the image z_x = bbox3d_size[0] * focal_length / (ratio * W) - min_corner[2] z_y = bbox3d_size[1] * focal_length / (ratio * H) - min_corner[2] z = max(z_x, z_y) translation = -center_3d translation[2] = z translation = translation[None, :] rot_vertex_list = [ rot_vert + translation for rot_vert in rot_vertex_list ] # render from side view img_side = imshow_mesh_3d( np.ones_like(img) * 255, rot_vertex_list, face_list, img_center, [focal_length, focal_length]) # merger images from front view and side view img_vis = np.concatenate([img_vis, img_side], axis=1) if show: mmcv.visualization.imshow(img_vis, win_name, wait_time) if out_file is not None: mmcv.imwrite(img_vis, out_file) return img_vis