def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kwargs): """Write optical flow to file. If the flow is not quantized, it will be saved as a .flo file losslessly, otherwise a jpeg image which is lossy but of much smaller size. (dx and dy will be concatenated horizontally into a single image if quantize is True.) Args: flow (ndarray): (h, w, 2) array of optical flow. filename (str): Output filepath. quantize (bool): Whether to quantize the flow and save it to 2 jpeg images. If set to True, remaining args will be passed to :func:`quantize_flow`. concat_axis (int): The axis that dx and dy are concatenated, can be either 0 or 1. Ignored if quantize is False. """ if not quantize: with open(filename, 'wb') as f: f.write('PIEH'.encode('utf-8')) np.array([flow.shape[1], flow.shape[0]], dtype=np.int32).tofile(f) flow = flow.astype(np.float32) flow.tofile(f) f.flush() else: assert concat_axis in [0, 1] dx, dy = quantize_flow(flow, *args, **kwargs) dxdy = np.concatenate((dx, dy), axis=concat_axis) imwrite(dxdy, filename)
def imshow_det_bboxes(self, img, bboxes, texts, out_file): # draw text def change_cv2_draw(image, strs, local, sizes, color): cv2img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) pilimg = Image.fromarray(cv2img) draw = ImageDraw.Draw(pilimg) font = ImageFont.truetype('resource/simsun.ttc', sizes, encoding="utf-8") draw.text(local, strs, color, font=font) image = cv2.cvtColor(np.array(pilimg), cv2.COLOR_RGB2BGR) return image img = imread(img) bbox_color = (255, 0, 0) text_color = (0, 0, 255) for i in range(len(texts)): bbox = bboxes[i].astype(np.int32) text = texts[i] cv2.drawContours(img, [bbox], -1, bbox_color, 2) tl = np.min(bbox, 0) img = change_cv2_draw(img, text, (tl[0], tl[1]), 20, text_color) imwrite(img, out_file)
def imshow_bboxes(img, bboxes, bbox_color=(255, 255, 255), thickness=1, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4). bbox_color (RGB value): Color of bbox lines. thickness (int): Thickness of lines. show (bool): Whether to show the image. win_name (str): The window name. wait_time (int): Value of waitKey param. out_file (str or None): The filename to write the image. """ assert bboxes.ndim == 2 assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 for bbox in bboxes: bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) img = cv2.rectangle(img, left_top, right_bottom, bbox_color, thickness) if show: cv2.imshow(win_name, img) cv2.waitKey(wait_time) if out_file is not None: imwrite(img, out_file)
def show_seg_result( img, result, # list masks[cls]->list class_names, score_thr=0.3, wait_time=0, show=True, out_file=None): """Visualize the detection results on the image. Args: img (str or np.ndarray): Image filename or loaded image. result (tuple[list] or list): The detection result, can be either (bbox, segm) or just bbox. class_names (list[str] or tuple[str]): A list of class names. score_thr (float): The threshold to visualize the bboxes and masks. wait_time (int): Value of waitKey param. show (bool, optional): Whether to show the image with opencv or not. out_file (str, optional): If specified, the visualization result will be written to the out file instead of shown in a window. Returns: np.ndarray or None: If neither `show` nor `out_file` is specified, the visualized image is returned, otherwise None is returned. """ assert isinstance(class_names, (tuple, list)) img = mmcv.imread(img) img = img.copy() segm_result = result labels = [ np.full(len(s), i, dtype=np.int32) for i, s in enumerate(segm_result) ] labels = np.concatenate(labels) # 100 if segm_result is not None: segms = mmcv.concat_list(segm_result) segms = np.vstack(segms) inds = np.where(segms[:, -1] > score_thr)[0] np.random.seed(42) color_masks = [ np.random.randint(0, 256, (1, 3), dtype=np.uint8) for _ in range(max(labels) + 1) ] for i in inds: i = int(i) color_mask = color_masks[labels[i]] mask = mask_util.decode(segms[i][0]).astype(np.bool) img[mask] = img[mask] * 0.5 + color_mask * 0.5 cur_label = labels[i] label_text = class_names[cur_label] center_y, center_x = ndimage.measurements.center_of_mass(mask) vis_pos = (max(int(center_x) - 10, 0), int(center_y)) cv2.putText(img, label_text, vis_pos, cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255)) # green if out_file is not None: imwrite(img, out_file)
def imshow_tracklets(img, bboxes, labels=None, ids=None, thickness=2, font_scale=0.4, show=False, win_name='', color=None, out_file=None): assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 if isinstance(img, str): img = imread(img) i = 0 for bbox, label in zip(bboxes, labels): x1, y1, x2, y2, _ = bbox.astype(np.int32) if ids is not None: if color is None: bbox_color = random_color(ids[i]) bbox_color = [int(255 * _c) for _c in bbox_color][::-1] else: bbox_color = mmcv.color_val(color) img[y1:y1 + 12, x1:x1 + 20, :] = bbox_color cv2.putText(img, str(ids[i]), (x1, y1 + 10), cv2.FONT_HERSHEY_COMPLEX, font_scale, color=color_val('black')) else: if color is None: bbox_color = color_val('green') else: bbox_color = mmcv.color_val(color) cv2.rectangle(img, (x1, y1), (x2, y2), bbox_color, thickness=thickness) if bbox[-1] < 0: bbox[-1] = np.nan label_text = '{:.02f}'.format(bbox[-1]) img[y1 - 12:y1, x1:x1 + 30, :] = bbox_color cv2.putText(img, label_text, (x1, y1 - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, color=color_val('black')) i += 1 if show: imshow(img, win_name) if out_file is not None: imwrite(img, out_file) return img
def imshow_bboxes(img, bboxes, colors='green', top_k=-1, thickness=1, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes on an image. Args: img (str or ndarray): The image to be displayed. bboxes (list or ndarray): A list of ndarray of shape (k, 4). colors (list[str or tuple or Color]): A list of colors. top_k (int): Plot the first k bboxes only if set positive. thickness (int): Thickness of lines. 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. """ img = imread(img) img = np.ascontiguousarray(img) if isinstance(bboxes, np.ndarray): bboxes = [bboxes] if not isinstance(colors, list): colors = [colors for _ in range(len(bboxes))] colors = [color_val(c) for c in colors] assert len(bboxes) == len(colors) for i, _bboxes in enumerate(bboxes): _bboxes = _bboxes.astype(np.int32) if top_k <= 0: _top_k = _bboxes.shape[0] else: _top_k = min(top_k, _bboxes.shape[0]) for j in range(_top_k): left_top = (_bboxes[j, 0], _bboxes[j, 1]) right_bottom = (_bboxes[j, 2], _bboxes[j, 3]) cv2.rectangle(img, left_top, right_bottom, colors[i], 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_custom(img, bboxes, colors='green', top_k=-1, thickness=1, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes on an image. Args: img (str or ndarray): The image to be displayed. bboxes (list or ndarray): A list of ndarray of shape (k, 4). colors (list[str or tuple or Color]): A list of colors. top_k (int): Plot the first k bboxes only if set positive. thickness (int): Thickness of lines. 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. """ img = imread(img) if isinstance(bboxes, np.ndarray): bboxes = [bboxes] if not isinstance(colors, list): colors = [colors for _ in range(len(bboxes))] colors = [color_val(c) for c in colors] assert len(bboxes) == len(colors) for i, _bboxes in enumerate(bboxes): label_text = _bboxes[:, 4] color_text = color_val('green') _bboxes = _bboxes.astype(np.int32) if top_k <= 0: _top_k = _bboxes.shape[0] else: _top_k = min(top_k, _bboxes.shape[0]) for j in range(_top_k): left_top = (_bboxes[j, 0], _bboxes[j, 1]) right_bottom = (_bboxes[j, 2], _bboxes[j, 3]) cv2.rectangle(img, left_top, right_bottom, colors[i], thickness=thickness) cv2.putText(img, '{:.02f}'.format(label_text[j]), (_bboxes[j, 0], _bboxes[j, 3] - 2), cv2.FONT_HERSHEY_COMPLEX, 1, color_text) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def single_gpu_test(model, data_loader, show=False, eval_num=None): model.eval() results = [] dataset = data_loader.dataset prog_bar = mmcv.ProgressBar(len(dataset)) for i, data in enumerate(data_loader): if eval_num is not None and i >= eval_num: break if show: # model.module.show_result(data, result) # model.module.show_result(data, result, dataset.img_norm_cfg) ins_all, cls_all, img_name = ins_gt_color(data) level_num = len(ins_all) out_folder = os.path.join('vis_tmp_gt/', img_name) out_folder_cls = os.path.join('vis_tmp_gt/', img_name + '_cls') if not os.path.exists(out_folder): os.makedirs(out_folder) if not os.path.exists(out_folder_cls): os.makedirs(out_folder_cls) for j in range(level_num): out_name = os.path.join(out_folder, "%02d" % (j) + '.jpg') out_name_cls = os.path.join(out_folder_cls, "%02d" % (j) + '.jpg') imwrite(ins_all[j], out_name) if len(cls_all) > 0: imwrite(cls_all[j], out_name_cls) del data['gt_labels'] del data['gt_masks'] del data['gt_bboxes'] del data['category_targets'] del data['point_ins'] with torch.no_grad(): result = model(return_loss=False, rescale=not show, **data) results.append(result) batch_size = data['img'][0].size(0) for _ in range(batch_size): prog_bar.update() return results
def show_det_bboxes(img, bboxes, labels, out_file, gt_bboxes=None, class_names=None, score_thr=0.05, bbox_color='yellow', gt_color='green', top_k=5): assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] topinds = np.argsort(bboxes[:, 4]) topinds = topinds[:top_k] if len(topinds) >= top_k else topinds bboxes = bboxes[topinds, :] labels = labels[topinds] bbox_color = color_val(bbox_color) gt_color = color_val(gt_color) for bbox, label in zip(bboxes, labels): addBox(img, bbox, bbox_color, label, class_names=class_names) if gt_bboxes is not None: assert len(gt_bboxes) == 1 gt_bboxes = gt_bboxes[0] for gt_box in gt_bboxes: gt_box = gt_box.numpy() addBox(img, gt_box, gt_color, 0, class_names=class_names) imwrite(img, out_file)
def imshow_det_bboxes(self, img, bboxes, labels, show=True, out_file=None): assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if self.score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > self.score_thr bboxes = bboxes[inds, :] labels = labels[inds] img = np.ascontiguousarray(img) for bbox, label in zip(bboxes, labels): bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) cv2.rectangle(img, left_top, right_bottom, self.colors[label], thickness=self.thickness) label_text = self.classes[ label] if self.classes is not None else f'cls {label}' if len(bbox) > 4: label_text += f'|{bbox[-1]:.02f}' cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - (label * 2 * randint(0, 1))), cv2.FONT_HERSHEY_COMPLEX, self.font_scale, self.colors[label]) if show: imshow(img, self.win_name, self.wait_time) if out_file is not None: imwrite(img, out_file) return img
def imshow_det_bboxes(img, bboxes, labels, class_names=None, score_thr=0, bbox_color='green', text_color='green', thickness=3, font_scale=0.8, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = random_colors(80) # color_val(bbox_color) text_color = random_colors(80) # color_val(text_color) for bbox, label in zip(bboxes, labels): bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) tmp_bbox_color = bbox_color[label] tmp_bbox_color = (int(tmp_bbox_color[2] * 255), int(tmp_bbox_color[1] * 255), int(tmp_bbox_color[0] * 255)) cv2.rectangle(img, left_top, right_bottom, tmp_bbox_color, thickness=thickness) 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, tmp_bbox_color) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def show_result(self, data, result, img_norm_cfg, dataset=None, score_thr=0.3, out_file=None): with_sema = False if isinstance(result, tuple): if len(result) == 2: bbox_result, segm_result = result else: bbox_result, segm_result, sema_result = result with_sema = True 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) for i, bbox in enumerate(bbox_result) ] labels = np.concatenate(labels) mmcv.imshow_det_bboxes( img_show, bboxes, labels, bbox_color='red', text_color='red', show=out_file is None, class_names=class_names, score_thr=score_thr, out_file=out_file) if with_sema is True: sema_result = mmcv.imresize(sema_result, (w, h), interpolation='nearest') imwrite(sema_result, out_file[:-4] + '-sema.png')
def draw_det_bboxes_A(img_name, bboxes, labels, imgd, colors, width=None, class_names=None, score_thr=0.5, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. out_file (str or None): The filename to write the image. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img_name) img = img.copy() ori_size = img.shape ratio = width / ori_size[0] img = cv2.resize(img, (int(ori_size[1] * ratio), int(ori_size[0] * ratio))) scores = bboxes[:, -1] if score_thr > 0.0: assert bboxes.shape[1] == 5 inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] scores = scores[inds] # Pred = Prediction(img_name = str(imgd), # pred_num = labels.shape[0], # img = imgd) # Pred.save() imgd.pred_num = labels.shape[0] imgd.save() if labels.shape[0] == 0: write_det(imgd, box_id='', pred_cls='', score=0, bbox_int=None, nodet=True) ABC = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' i = 0 for bbox, label, score in zip(bboxes, labels, scores): pred_cls = class_names[label] color = colors[pred_cls] box_id = ABC[i] bbox = bbox * ratio bbox_int = bbox.astype(np.int32) write_det(imgd, box_id, pred_cls, score, bbox_int) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) cv2.rectangle(img, (left_top[0], left_top[1]), (right_bottom[0], right_bottom[1]), color, 4) text_size, baseline = cv2.getTextSize(box_id, cv2.FONT_HERSHEY_SIMPLEX, 1.3, 2) p1 = (left_top[0], left_top[1] + text_size[1]) cv2.rectangle(img, tuple(left_top), (p1[0] + text_size[0], p1[1] + 1), color, -1) cv2.putText(img, box_id, (p1[0], p1[1]), cv2.FONT_HERSHEY_SIMPLEX, 1.3, (255, 255, 255), 2, 8) i += 1 print('done ' + str(out_file)) if out_file is not None: imwrite(img, out_file) return i
def load_anno_idx( self, idx, img_concat, train, draw_dir='/data/home/yyj/code/kaggle/new_code/Kaggle_PKU_Baidu/data/pku_data/crop_visualization/crop_mesh' ): bboxes = [] img1, img2, img3 = img_concat mask_all = np.zeros(img1.shape) merged_image1 = img1.copy() merged_image2 = img2.copy() merged_image3 = img3.copy() alpha = 0.8 # transparency gt = self._str2coords(train['PredictionString'].iloc[idx]) for gt_pred in gt: eular_angle = np.array( [gt_pred['yaw'], gt_pred['pitch'], gt_pred['roll']]) translation = np.array([gt_pred['x'], gt_pred['y'], gt_pred['z']]) quaternion = euler_angles_to_quaternions(eular_angle) quaternion_semisphere = quaternion_upper_hemispher(quaternion) new_eular_angle = quaternion_to_euler_angle(quaternion_semisphere) # rendering the car according to: # https://www.kaggle.com/ebouteillon/augmented-reality # car_id2name is from: # https://github.com/ApolloScapeAuto/dataset-api/blob/master/car_instance/car_models.py car_name = car_id2name[gt_pred['id']].name vertices = np.array(self.car_model_dict[car_name]['vertices']) vertices[:, 1] = -vertices[:, 1] triangles = np.array(self.car_model_dict[car_name]['faces']) - 1 # project 3D points to 2d image plane yaw, pitch, roll = gt_pred['yaw'], gt_pred['pitch'], gt_pred[ 'roll'] # I think the pitch and yaw should be exchanged yaw, pitch, roll = -pitch, -yaw, -roll Rt = np.eye(4) t = np.array([gt_pred['x'], gt_pred['y'], gt_pred['z']]) Rt[:3, 3] = t Rt[:3, :3] = euler_to_Rot(yaw, pitch, roll).T Rt = Rt[:3, :] P = np.ones((vertices.shape[0], vertices.shape[1] + 1)) P[:, :-1] = vertices P = P.T img_cor_points = np.dot(self.camera_matrix, np.dot(Rt, P)) img_cor_points = img_cor_points.T img_cor_points[:, 0] /= img_cor_points[:, 2] img_cor_points[:, 1] /= img_cor_points[:, 2] # project 3D points to 2d image plane x1, y1, x2, y2 = img_cor_points[:, 0].min(), img_cor_points[:, 1].min( ), img_cor_points[:, 0].max( ), img_cor_points[:, 1].max() bboxes.append([x1, y1, x2, y2]) # project 3D points to 2d image plane mask_seg = np.zeros(img1.shape, dtype=np.uint8) mask_seg_mesh = np.zeros(img1.shape, dtype=np.uint8) for t in triangles: coord = np.array([ img_cor_points[t[0]][:2], img_cor_points[t[1]][:2], img_cor_points[t[2]][:2] ], dtype=np.int32) # This will draw the mask for segmenation cv2.drawContours(mask_seg, np.int32([coord]), 0, (0, 0, 255), -1) # cv2.polylines(mask_seg_mesh, np.int32([coord]), 1, (0, 255, 0)) mask_all += mask_seg # if False: mask_all = mask_all * 255 / mask_all.max() cv2.addWeighted(img1.astype(np.uint8), 1.0, mask_all.astype(np.uint8), alpha, 0, merged_image1) cv2.addWeighted(img2.astype(np.uint8), 1.0, mask_all.astype(np.uint8), alpha, 0, merged_image2) cv2.addWeighted(img3.astype(np.uint8), 1.0, mask_all.astype(np.uint8), alpha, 0, merged_image3) imwrite(merged_image1, os.path.join(draw_dir, train['ImageId'].iloc[idx] + '_1.jpg')) imwrite(merged_image2, os.path.join(draw_dir, train['ImageId'].iloc[idx] + '_2.jpg')) imwrite(merged_image3, os.path.join(draw_dir, train['ImageId'].iloc[idx] + '_3.jpg'))
def show_det_lines(img, lines, labels, class_names=None, score_thr=0, line_color='green', text_color='green', thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None, key_points=None, point_color='red', scores=None): ''' img: [h,w,3] lines: [n,6] labels: [n] scores: [n] or None Use lines[:,-1] as score when scores is None, otherwise use scores as the score for filtering lines. Always show lines[:,-1] in the image. ''' assert lines.ndim == 2 assert lines.shape[1] == 6 or lines.shape[1] == 5 assert labels.ndim == 1 assert labels.shape[0] == lines.shape[0] if key_points is not None: assert key_points.shape[0] == lines.shape[0] img = imread(img.copy()) if score_thr > 0: assert lines.shape[1] == 6 if scores is None: inds = lines[:, -1] > score_thr else: inds = scores > score_thr lines = lines[inds, :] labels = labels[inds] if key_points is not None: key_points = key_points[inds, :] line_color = color_val(line_color) text_color = color_val(text_color) point_color = color_val(point_color) i = -1 for line, label in zip(lines, labels): i += 1 istopleft = line[4] >= 0 if not istopleft: line[0], line[2] = line[2], line[0] line_int = line.astype(np.int32) s = line_int[0:2] e = line_int[2:4] line_color = get_random_color() cv2.line(img, (s[0], s[1]), (e[0], e[1]), line_color, thickness=thickness) if key_points is not None: for j in range(key_points.shape[1]): p = key_points[i][j].astype(np.int32) cv2.circle(img, (p[0], p[1]), 2, point_color, thickness=thickness) label_text = class_names[ label] if class_names is not None else 'cls {}'.format(label) label_text = '' if len(line) == 6: if DEBUG_CFG.OBJ_LEGEND == 'score': label_text += '{:.01f}'.format(line[-1]) # score else: label_text += '{:.01f}'.format(line[-2]) # rotation m = ((s + e) / 2).astype(np.int32) cv2.putText(img, label_text, (m[0] - 2, m[1] - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) print('\twrite {}'.format(out_file)) pass
def imshow_det_bboxes(img, bboxes, labels, class_names=None, score_thr=0.3, bbox_color='green', text_color='white', thickness=2, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None, image_id=0): assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = color_val(bbox_color) text_color = color_val(text_color) # results[image_id] = [] # do tracking bbox_xyxy = bboxes[:,:4] cls_conf = bboxes[..., 4] w = bbox_xyxy[..., 2] - bbox_xyxy[..., 0] h = bbox_xyxy[..., 3] - bbox_xyxy[..., 1] bbox_xyxy[:, 2] = w bbox_xyxy[:, 3] = h index = 0 outbb = np.copy(bbox_xyxy) dd = [] for bbox, label in zip(bboxes, labels): if label != 0: dd.append(index) index += 1 outbb = np.delete(outbb, dd, 0) cls_conf = np.delete(cls_conf, dd, 0) labels = np.delete(labels, dd, 0) if image_id ==1: for i in range(2): outputs = deepsort.update(outbb, cls_conf, img) else: outputs = deepsort.update(outbb, cls_conf, img) if len(outputs) > 0: bboxes = outputs[:, :4] ids = outputs[:, -1] for bbox, label, id in zip(bboxes, labels, ids): if label == 0: bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) cv2.rectangle( img, left_top, right_bottom, bbox_color, thickness=thickness) label_text = 'ID {}'.format(id) if len(bbox) > 4: label_text += '|{:.02f}'.format(bbox[-1]) _height_half = int((bbox_int[3]-bbox_int[1])/2) cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] + _height_half), cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color) mybbox = bbox.astype(np.float).tolist() results.append((image_id, mybbox, id)) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def imshow_det_pts(img, bboxes, pts, labels, class_names=None, score_thr=0, thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, draw_pts=True, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. """ assert pts.ndim == 2 assert labels.ndim == 1 assert pts.shape[0] == labels.shape[0] img = imread(img) if score_thr > 0: scores = pts[:, -1] inds = scores > score_thr pts = pts[inds, :] bboxes = bboxes[inds, :] labels = labels[inds] for pt, bbox, label in zip(pts, bboxes, labels): r_color = (np.random.randint(0, 256), np.random.randint(0, 256), np.random.randint(0, 256)) pt_x = pt[0:-1:3] pt_y = pt[1:-1:3] pt_score = pt[2:-1:3] left_top = (int(bbox[0]), int(bbox[1])) right_bottom = (int(bbox[2]), int(bbox[3])) cv2.rectangle( img, left_top, right_bottom, r_color, thickness=thickness) if draw_pts: for i in range(pt_x.shape[0]): r_fore_color = r_color r_back_color = [int(i / 2) for i in r_color] r_show_color = r_fore_color if pt_score[i] > 0.5 else r_back_color cv2.circle(img, (pt_x[i], pt_y[i]), 1, r_show_color, thickness=2) label_text = class_names[ label] if class_names is not None else 'cls {}'.format(label) if len(pt) % 2 == 1: label_text += '|{:.02f}'.format(pt[-1]) cv2.putText(img, label_text, (int(bbox[0]), int(bbox[1]) - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, r_color) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def imshow_det_rbboxes(img, bboxes, labels, class_names=None, score_thr=0, bbox_color='green', text_color='green', thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 5) or (n, 6). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 5 or bboxes.shape[1] == 6 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 6 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = color_val(bbox_color) text_color = color_val(text_color) for bbox, label in zip(bboxes, labels): xc, yc, w, h, ag, p = bbox.tolist() wx, wy = w / 2 * math.cos(ag), w / 2 * math.sin(ag) hx, hy = -h / 2 * math.sin(ag), h / 2 * math.cos(ag) p1 = (xc - wx - hx, yc - wy - hy) p2 = (xc + wx - hx, yc + wy - hy) p3 = (xc + wx + hx, yc + wy + hy) p4 = (xc - wx + hx, yc - wy + hy) ps = np.int0(np.array([p1, p2, p3, p4])) cv2.drawContours(img, [ps], -1, bbox_color, thickness=thickness) label_text = class_names[ label] if class_names is not None else 'cls {}'.format(label) if len(bbox) > 5: label_text += '|{:.02f}'.format(bbox[-1]) cv2.putText(img, label_text, (int(p1[0]), int(p1[1])), cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def imshow_det_rbboxes_360(img, bboxes, labels, class_names=None, score_thr=0, bbox_color='green', text_color='red', thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 5) or (n, 6). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 5 or bboxes.shape[1] == 6 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 6 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = color_val(bbox_color) text_color = color_val(text_color) for bbox, label in zip(bboxes, labels): xc, yc, w, h, ag, p = bbox.tolist() wx, wy = w / 2 * math.cos(ag), w / 2 * math.sin(ag) hx, hy = -h / 2 * math.sin(ag), h / 2 * math.cos(ag) p1 = (xc - wx - hx, yc - wy - hy) p2 = (xc + wx - hx, yc + wy - hy) p3 = (xc + wx + hx, yc + wy + hy) p4 = (xc - wx + hx, yc - wy + hy) ps = np.int0(np.array([p1, p2, p3, p4])) cv2.drawContours(img, [ps], -1, bbox_color, thickness=thickness) label_text = class_names[ label] if class_names is not None else 'cls {}'.format(label) ############## # transfer 4 directions to 360 ag = ag / math.pi * 180 if "RUP" in label_text: ag += 90 elif "RDOWN" in label_text: ag += 180 elif "LDOWN" in label_text: ag += 270 else: ag += 360 if ag < 0: ag += 360 print("negative:{},{}".format(ag, out_file)) # Draw direction line p1_x, p1_y = xc, yc p2_x, p2_y = xc, yc - 80 rotateMat = cv2.getRotationMatrix2D((p1_x, p1_y), -ag, 1) [[p1_x], [p1_y]] = np.dot(rotateMat, np.array([[p1_x], [p1_y], [1]])) [[p2_x], [p2_y]] = np.dot(rotateMat, np.array([[p2_x], [p2_y], [1]])) cv2.line(img, (int(p1_x), int(p1_y)), (int(p2_x), int(p2_y)), text_color, thickness=thickness) label_text = label_text.split('-')[0] ############## if len(bbox) > 5: label_text += '|{:.02f}, {:.02f}'.format(bbox[-1], ag) cv2.putText(img, label_text, (int(p1[0]), int(p1[1])), cv2.FONT_HERSHEY_COMPLEX, font_scale, text_color) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
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
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, 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) # custom index label # font font = cv2.FONT_HERSHEY_SIMPLEX # org org = (50, 50) # fontScale fontScale = 1 # Blue color in BGR color = (255, 0, 0) # Line thickness of 2 px thickness = 2 cv2.putText(img_copy, str(kid), (int(x_coord), int(y_coord) - 10), font, fontScale, color, thickness, cv2.LINE_AA) 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) # custom index label # font font = cv2.FONT_HERSHEY_SIMPLEX # org org = (50, 50) # fontScale fontScale = 1 # Blue color in BGR color = (255, 0, 0) # Line thickness of 2 px thickness = 2 cv2.putText(img, str(kid), (int(x_coord), int(y_coord) - 10), font, fontScale, color, thickness, cv2.LINE_AA) # draw limbs if skeleton is not None and pose_limb_color is not None: #print('color: ', len(pose_limb_color), len(skeleton)) #print(skeleton) assert len(pose_limb_color) == len(skeleton) #print(kpts) for sk_id, sk in enumerate(skeleton): #print(sk_id) #print(sk) #print('************') 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_det_bboxes(img, bboxes, labels, class_names=None, score_thr=0, bbox_color='green', text_color='green', thickness=1, font_scale=0.5, show=True, win_name='', wait_time=0, out_file=None): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. Returns: ndarray: The image with bboxes drawn on it. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color01 = color_val(bbox_color) bbox_color02 = color_val('red') bbox_color03 = color_val('blue') text_color = color_val(text_color) img = np.ascontiguousarray(img) for bbox, label in zip(bboxes, labels): bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) if label == 1: cv2.rectangle(img, left_top, right_bottom, bbox_color01, thickness=thickness) elif label == 2: cv2.rectangle(img, left_top, right_bottom, bbox_color02, thickness=thickness) else: cv2.rectangle(img, left_top, right_bottom, bbox_color03, thickness=thickness) label_text = class_names[ label] if class_names is not None else f'cls {label}' if len(bbox) > 4: label_text += f'|{bbox[-1]:.02f}' if label == 1: cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, bbox_color02) elif label == 2: cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, bbox_color03) else: cv2.putText(img, label_text, (bbox_int[0], bbox_int[1] - 2), cv2.FONT_HERSHEY_COMPLEX, font_scale, bbox_color01) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
else: if inter >= iou_threshold: suppressed[j] = 1 return keep # 返回保留下来的下�? for i in range(len(imgs)): print(imgs[i]) img = Image.open(imgs[i]) img = np.asarray(img) result = inference_detector(model, img) img_data = copy.copy(img) print(result) indx, score, bbox = selectClsScoreBoxFromResult(result) # keep = NMS_alphaRatioConf(bbox, score, 0.7, 0.7) keep = nms(bbox, score, 0.3, 10, soft_nms=True) for n in keep: # if score[n] < 0.6*max(score): # continue left_top = (bbox[n][0], bbox[n][1]) right_bottom = (bbox[n][2], bbox[n][3]) cv2.rectangle(img_data, left_top, right_bottom, (0, 0, 255), thickness=2) strText = str(class_nums[indx[n]]) + ': ' + str(format( score[n], '.4f')) cv2.putText(img_data, strText, (bbox[n][0], bbox[n][1] - 20), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 0), 1) imwrite(img_data, os.path.join(save_path, files[i]))
def show_result(img, result, class_names, score_thr=0.8, wait_time=0, show=True, out_file=None): """Visualize the detection results on the image. Args: img (str or np.ndarray): Image filename or loaded image. result (tuple[list] or list): The detection result, can be either (bbox, segm) or just bbox. class_names (list[str] or tuple[str]): A list of class names. score_thr (float): The threshold to visualize the bboxes and masks. wait_time (int): Value of waitKey param. show (bool, optional): Whether to show the image with opencv or not. out_file (str, optional): If specified, the visualization result will be written to the out file instead of shown in a window. Returns: np.ndarray or None: If neither `show` nor `out_file` is specified, the visualized image is returned, otherwise None is returned. """ assert isinstance(class_names, (tuple, list)) img = mmcv.imread(img) img = img.copy() img[img < 255] = 255 if isinstance(result, tuple): bbox_result, segm_result = result else: bbox_result, segm_result = result, None bboxes = np.vstack(bbox_result) labels = [ np.full(bbox.shape[0], i, dtype=np.int32) for i, bbox in enumerate(bbox_result) ] labels = np.concatenate(labels) # draw segmentation masks if segm_result is not None: segms = mmcv.concat_list(segm_result) inds = np.where(bboxes[:, -1] > score_thr)[0] np.random.seed(42) color_masks = [ #np.random.randint(0, 256, (1, 3), dtype=np.uint8) [[0, 0, 0]] for _ in range(max(labels) + 1) ] for i in inds: i = int(i) color_mask = color_masks[labels[i]] mask = maskUtils.decode(segms[i]).astype(np.bool) img[mask] = color_mask #img[mask] = img[mask] * 0.5 + color_mask * 0.5 # if out_file specified, do not show image in window if out_file is not None: show = False # draw bounding boxes """ mmcv.imshow_det_bboxes( img, bboxes, labels, class_names=class_names, score_thr=score_thr, show=show, wait_time=wait_time, out_file=out_file) """ if show: imshow(img, win_name='', wait_time=0) if out_file is not None: imwrite(img, out_file) if not (show or 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, 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 (np.array[Nx3]`): Color of N keypoints. pose_limb_color (np.array[Mx3]): Color of M 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: img (Tensor): 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 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) 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) # 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_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: # cv2.line(img, pos1, pos2, pose_kpt_color, 2, 8) 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) r, g, b = pose_limb_color[sk_id] 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) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
def show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, bbox_color=None, pose_kpt_color=None, pose_limb_color=None, 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. 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. 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 image only if not `show` or `out_file` """ img = mmcv.imread(img) img = img.copy() img_h, img_w, _ = img.shape pose_result = [] for res in result: pose_result.append(res['keypoints']) 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 show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, pose_kpt_color=None, pose_limb_color=None, radius=4, 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. 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. 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 image only if not `show` or `out_file` """ img = mmcv.imread(img) img = img.copy() img_h, img_w, _ = img.shape pose_result = [] for res in result: pose_result.append(res['keypoints']) for person_id, 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: 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) # 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): 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) r, g, b = pose_limb_color[sk_id] 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) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
def imshow_det_bboxes( img, bboxes, labels, class_names=None, score_thr=0, bbox_color="green", text_color="green", thickness=1, font_scale=0.5, show=True, win_name="", wait_time=0, out_file=None, vis_tool="matplotlib", ): """Draw bboxes and class labels (with scores) on an image. Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. """ assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = color_val(bbox_color) text_color = color_val(text_color) for bbox, label in zip(bboxes, labels): bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) cv2.rectangle(img, left_top, right_bottom, bbox_color, thickness=thickness) 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) if show: if vis_tool == "matplotlib": fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100) tmp = fig.add_subplot(1, 1, 1) tmp.set_title("{}".format(win_name)) plt.axis("off") plt.imshow(img[:, :, [2, 1, 0]]) plt.show() else: # use 'mmcv' imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file)
def show_result(self, img, result, skeleton=None, kpt_score_thr=0.3, bbox_color='green', pose_kpt_color=None, pose_link_color=None, text_color='white', radius=4, thickness=1, font_scale=0.5, bbox_thickness=1, 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. skeleton is 0-based indexing. 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_link_color (np.array[Mx3]): Color of M links. If None, do not draw links. 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() bbox_result = [] bbox_labels = [] pose_result = [] for res in result: if 'bbox' in res: bbox_result.append(res['bbox']) bbox_labels.append(res.get('label', None)) pose_result.append(res['keypoints']) if bbox_result: bboxes = np.vstack(bbox_result) # draw bounding boxes imshow_bboxes(img, bboxes, labels=bbox_labels, colors=bbox_color, text_color=text_color, thickness=bbox_thickness, font_scale=font_scale, show=False) if pose_result: imshow_keypoints(img, pose_result, skeleton, kpt_score_thr, pose_kpt_color, pose_link_color, radius, thickness) if show: imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img
def imshow_det_bboxes_poses( img, bboxes, labels, class_names=None, score_thr=0, bbox_color="green", text_color="green", thickness=1, font_scale=0.5, show=True, win_name="", wait_time=0, out_file=None, poses=None, corners_3d=None, dataste_name=None, renderer=None, K=None, vis_tool="matplotlib", ): """Draw bboxes and class labels (with scores) on an image. Render the contours of poses to image. (or the 3d bounding box) Args: img (str or ndarray): The image to be displayed. bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or (n, 5). labels (ndarray): Labels of bboxes. 0-based class_names (list[str]): Names of each classes. score_thr (float): Minimum score of bboxes to be shown. bbox_color (str or tuple or :obj:`Color`): Color of bbox lines. 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 or None): The filename to write the image. ------ poses: corners_3d: dict of 3d corners(un-transformed), key is cls_name dataset_name: camera intrinsic parameter renderer: K: camera intrinsic """ # logger.info('poses: {}'.format(poses)) assert bboxes.ndim == 2 assert labels.ndim == 1 assert bboxes.shape[0] == labels.shape[0] assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5 img = imread(img) if score_thr > 0: assert bboxes.shape[1] == 5 scores = bboxes[:, -1] inds = scores > score_thr bboxes = bboxes[inds, :] labels = labels[inds] bbox_color = color_val(bbox_color) text_color = color_val(text_color) for bbox, label in zip(bboxes, labels): # pose if poses is not None: if poses[label]: pose = poses[label][0] # TODO: handle multiple poses bgr, depth = renderer.render(label, pose[:, :3], pose[:, 3], r_type="mat") # img = img - bgr pose_mask = np.zeros(depth.shape) pose_mask[depth != 0] = 1 edges_3 = mask_utils.get_edge(pose_mask, bw=3) edges_3[:, :, [0, 1]] = 0 # red img[edges_3 != 0] = 255 cls_name = class_names[label] corners_2d, _ = misc_6d.points_to_2D(corners_3d[cls_name], pose[:, :3], pose[:, 3], K) img = misc_6d.draw_projected_box3d(img, corners_2d, thickness=thickness) bbox_int = bbox.astype(np.int32) left_top = (bbox_int[0], bbox_int[1]) right_bottom = (bbox_int[2], bbox_int[3]) cv2.rectangle(img, left_top, right_bottom, bbox_color, thickness=thickness) 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) if show: if vis_tool == "matplotlib": fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100) tmp = fig.add_subplot(1, 1, 1) tmp.set_title("{}".format(win_name)) plt.axis("off") plt.imshow(img[:, :, [2, 1, 0]]) plt.show() else: # use 'mmcv' imshow(img, win_name, wait_time) if out_file is not None: imwrite(img, out_file) return img