def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', default=TRAINED_MODEL_DEFAULT) parser.add_argument('image') args = parser.parse_args() if args.pretrained_model == TRAINED_MODEL_DEFAULT and \ not os.path.exists(TRAINED_MODEL_DEFAULT): download_model.download_model(MODEL_URL, TRAINED_MODEL_DEFAULT) model = FasterRCNNVGG16(n_fg_class=1, pretrained_model=args.pretrained_model) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=('face', )) plot.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('faster_rcnn_fpn_resnet50', 'faster_rcnn_fpn_resnet101'), default='faster_rcnn_fpn_resnet50') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='coco') parser.add_argument('image') args = parser.parse_args() if args.model == 'faster_rcnn_fpn_resnet50': model = FasterRCNNFPNResNet50(n_fg_class=len(coco_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'faster_rcnn_fpn_resnet101': model = FasterRCNNFPNResNet101(n_fg_class=len(coco_bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image) bboxes, labels, scores = model.predict([img]) bbox = bboxes[0] label = labels[0] score = scores[0] vis_bbox(img, bbox, label, score, label_names=coco_bbox_label_names) plt.show()
def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model') parser.add_argument('image') parser.add_argument('--label_names', help='The path to the file with label names') args = parser.parse_args() with open(args.label_names, 'r') as f: label_names = f.read().splitlines() model = SSD300(n_fg_class=len(label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) model.nms_thresh = 0.45 model.score_thresh = 0.3 bboxes, labels, scores = model.predict([img]) print((bboxes, labels, scores)) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=label_names) plot.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', default='voc0712') parser.add_argument('image') args = parser.parse_args() if args.model == 'ssd300': model = SSD300( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'ssd512': model = SSD512( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox( img, bbox, label, score, label_names=voc_bbox_label_names) plot.show()
def main(): dataset = VOCBboxDataset(year='2007', split='test') models = [ ('Faster R-CNN', FasterRCNNVGG16(pretrained_model='voc07')), ('SSD300', SSD300(pretrained_model='voc0712')), ('SSD512', SSD512(pretrained_model='voc0712')), ] indices = [29, 301, 189, 229] fig = plot.figure(figsize=(30, 30)) for i, idx in enumerate(indices): for j, (name, model) in enumerate(models): img, _, _ = dataset[idx] bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] ax = fig.add_subplot( len(indices), len(models), i * len(models) + j + 1) vis_bbox( img, bbox, label, score, label_names=voc_bbox_label_names, ax=ax ) # Set MatplotLib parameters ax.set_aspect('equal') if i == 0: font = FontProperties() font.set_family('serif') ax.set_title(name, fontsize=35, y=1.03, fontproperties=font) plot.axis('off') plot.tight_layout() plot.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model') parser.add_argument('--dataset', choices=('voc', ), default='voc') parser.add_argument('image') args = parser.parse_args() if args.dataset == 'voc': if args.pretrained_model is None: args.pretrained_model = 'voc07' label_names = voc_bbox_label_names model = FasterRCNNVGG16(n_fg_class=len(label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=label_names) plt.show()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='voc0712') parser.add_argument('image') args = parser.parse_args() if args.model == 'ssd300': model = SSD300(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'ssd512': model = SSD512(n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=voc_bbox_label_names) plt.show()
def save_bbox(img, bbox, filename=None, label=None, score=None, label_names=None, instance_colors=None, alpha=1.0, linewidth=3.0, sort_by_score=True, ax=None): vis_bbox(img, bbox, label=label, score=score, label_names=label_names, instance_colors=instance_colors, alpha=alpha, linewidth=linewidth, sort_by_score=sort_by_score, ax=ax) plt.tick_params(labelbottom=False, labelleft=False, labelright=False, labeltop=False) plt.tick_params(bottom=False, left=False, right=False, top=False) plt.savefig(filename, bbox_inches='tight', pad_inches=0) plt.close()
def main(): dataset = VOCBboxDataset(year='2007', split='test') models = [ ('Faster R-CNN', FasterRCNNVGG16(pretrained_model='voc07')), ('SSD300', SSD300(pretrained_model='voc0712')), ('SSD512', SSD512(pretrained_model='voc0712')), ] indices = [29, 301, 189, 229] fig = plt.figure(figsize=(30, 30)) for i, idx in enumerate(indices): for j, (name, model) in enumerate(models): img, _, _ = dataset[idx] bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] ax = fig.add_subplot( len(indices), len(models), i * len(models) + j + 1) vis_bbox( img, bbox, label, score, label_names=voc_bbox_label_names, ax=ax ) # Set MatplotLib parameters ax.set_aspect('equal') if i == 0: font = FontProperties() font.set_family('serif') ax.set_title(name, fontsize=35, y=1.03, fontproperties=font) plt.axis('off') plt.tight_layout() plt.show()
def runYOLO(): '''parser = argparse.ArgumentParser() parser.add_argument( '--model', choices=('yolo_v2', 'yolo_v3'), default='yolo_v2') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='voc0712') parser.add_argument('image') args = parser.parse_args()''' aimage = 'sample7.jpg' amodel = 'yolo_v2' apretrained_model = 'voc0712' agpu = -1 if amodel == 'yolo_v2': model = YOLOv2(n_fg_class=len(voc_bbox_label_names), pretrained_model=apretrained_model) elif amodel == 'yolo_v3': model = YOLOv3(n_fg_class=len(voc_bbox_label_names), pretrained_model=apretrained_model) if agpu >= 0: chainer.cuda.get_device_from_id(agpu).use() model.to_gpu() img = utils.read_image(aimage, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=voc_bbox_label_names)
def detectChocoballImage(self, img): """ ChocoBallの個数をカウントする Args: img : jpeg image (binary) Returns: dict{'img':image_binary, 'box':[[ymin,xmin,ymax,xmax]], 'objects':[object_id], 'scores':[score]} """ #img_pil = Image.open(BytesIO(img)) img_pil = Image.open(img) print(img_pil.size) if img_pil.size[0] > self.MAX_WIDTH: img_pil.thumbnail(size=(self.MAX_WIDTH, self.MAX_WIDTH)) print(img_pil.size) img_arr = np.asarray(img_pil).transpose(2, 0, 1).astype(np.float32) bboxes, labels, scores = self.model_frcnn.predict([img_arr]) fig = plt.figure(figsize=(5, 4)) ax = fig.subplots(1, 1) ax.tick_params(labelbottom="off", bottom="off") ax.tick_params(labelleft="off", left="off") vis_bbox(img_arr, bboxes[0], labels[0], ax=ax) plt.savefig('tmp/tmp.png', bbox_inches="tight", pad_inches=0.0) with open('tmp/tmp.png', 'rb') as f: img_b = f.read() return {'img': img_b, 'box': bboxes[0], 'objects': labels[0], 'scores': scores[0]}
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--base-network', choices=('vgg16', 'resnet101'), default='vgg16', help='Base network') parser.add_argument('--pretrained-model', required=True) parser.add_argument('image') args = parser.parse_args() if args.base_network == 'vgg16': model = chainercv.links.SSD300( n_fg_class=len(roaddamage_label_names), pretrained_model=args.pretrained_model) elif args.base_network == 'resnet101': model = ssd_resnet101.SSD224( n_fg_class=len(roaddamage_label_names), pretrained_model=args.pretrained_model) else: raise ValueError('Invalid base network') if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox( img, bbox, label, score, label_names=roaddamage_label_names) plt.axis('off') plt.show()
def image_cb(self, msg): img = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8') H, W = img.shape[:2] objs = self.engine.DetectWithImage(PIL.Image.fromarray(img), threshold=self.score_thresh, keep_aspect_ratio=True, relative_coord=True, top_k=self.top_k) bboxes = [] scores = [] labels = [] rect_msg = RectArray(header=msg.header) for obj in objs: x_min, y_min, x_max, y_max = obj.bounding_box.flatten().tolist() x_min = int(np.round(x_min * W)) y_min = int(np.round(y_min * H)) x_max = int(np.round(x_max * W)) y_max = int(np.round(y_max * H)) bboxes.append([y_min, x_min, y_max, x_max]) scores.append(obj.score) labels.append(self.label_ids.index(int(obj.label_id))) rect = Rect(x=x_min, y=y_min, width=x_max - x_min, height=y_max - y_min) rect_msg.rects.append(rect) bboxes = np.array(bboxes) scores = np.array(scores) labels = np.array(labels) cls_msg = ClassificationResult( header=msg.header, classifier=self.classifier_name, target_names=self.label_names, labels=labels, label_names=[self.label_names[l] for l in labels], label_proba=scores) self.pub_rects.publish(rect_msg) self.pub_class.publish(cls_msg) if self.visualize: vis_img = img[:, :, ::-1].transpose(2, 0, 1) vis_bbox(vis_img, bboxes, labels, scores, label_names=self.label_names) fig = plt.gcf() fig.canvas.draw() w, h = fig.canvas.get_width_height() vis_img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8) fig.clf() vis_img.shape = (h, w, 3) plt.close() vis_msg = self.bridge.cv2_to_imgmsg(vis_img, 'rgb8') vis_msg.header = msg.header self.pub_image.publish(vis_msg)
def detect(image, model="ssd300", gpu=-1, pretrained_model="voc0712"): detector = Detector(model, gpu, pretrained_model) img = utils.read_image(image, color=True) bbox, label, score = detector(image) vis_bbox(img, bbox, label, score, label_names=voc_bbox_label_names) plt.show()
def test_vis_bbox_invalid_inputs(self): if not optional_modules: return with self.assertRaises(ValueError): vis_bbox( self.img, self.bbox, self.label, self.score, label_names=self.label_names)
def test_vis_bbox_invalid_inputs(self): with self.assertRaises(ValueError): vis_bbox(self.img, self.bbox, self.label, self.score, label_names=self.label_names, instance_colors=self.instance_colors, sort_by_score=self.sort_by_score)
def save_result_images(self, image, save_as, bboxes, labels, scores): if (self.model == 'fasterrcnnfpnresnet50') or (self.model == 'fasterrcnnfpnresnet101'): bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(image, bbox, label, score, label_names=coco_bbox_label_names) else: vis_bbox(image, bboxes[0], labels[0], scores[0], label_names=voc_bbox_label_names) plt.savefig(save_as)
def test_vis_bbox_invalid_inputs(self): if not optional_modules: return with self.assertRaises(ValueError): vis_bbox(self.img, self.bbox, self.label, self.score, label_names=self.label_names)
def __call__(self, img, bbox, label=None, score=None, save=False, path=None): vis_bbox( img, bbox, label, score, label_names=self.names ) plt.xticks([]) plt.yticks([]) if save: if path is None: raise ValueError('Path should be set') plt.savefig(path) else: plt.show()
def save_data(image, bbox, mask): import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt from chainercv import visualizations img = np.concatenate((image, image, mask * 255), axis=0) visualizations.vis_bbox(img, bbox) global N plt.savefig('data/{}.png'.format(N)) N += 1 plt.close()
def runRCNN(): startTime = time.time() #print(startTime) # Read an RGB image and return it in CHW format. img = read_image('sample7.jpg') model = SSD300(pretrained_model='voc0712') model1 = SSD512(pretrained_model='voc0712') bboxes, labels, scores = model1.predict([img]) vis_bbox(img, bboxes[0], labels[0], scores[0], label_names=voc_bbox_label_names) print(time.time() - startTime)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--engine', required=False, help='TensorRT engine file. If None, chainer-based ' 'inference will run') parser.add_argument('--n-try', '-n', type=int, default=1000) parser.add_argument('--chainer', action='store_true') parser.add_argument('image') args = parser.parse_args() model = YOLOv2(n_fg_class=len(voc_bbox_label_names), pretrained_model='voc0712') img = utils.read_image(args.image, color=True) chainer.cuda.get_device_from_id(args.gpu).use() if args.engine is not None: # Key idea: # `predict` method applies some pre-processings and preparations, # runs forward-pass and some post-processings. # We want to re-use all of them without copy-and-pasting the code, # while only forward-pass runs with TensorRT. # solution: replace __call__ and let `predict` call it, # as if it is the original python based forward pass def run_infer(self, x): return tuple(chainer.Variable(t) for t in infer(x)) infer = chainer_trt.Infer(args.engine) # NOQA type(model).__call__ = run_infer print("Loaded TensorRT inference engine {}".format(args.engine)) else: model.to_gpu() print("Run Chainer based inference") # Run inference once and get detections # (1st execution tends to be slow in CUDA) bboxes, labels, scores = model.predict([img]) before = time.time() for _ in range(args.n_try): model.predict([img]) after = time.time() print('{:.3f}ms/img'.format(1000 * (after - before) / args.n_try)) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox(img, bbox, label, score, label_names=voc_bbox_label_names) plt.show()
def publish_bbox_image(self, img, bbox, label, score): vis_bbox(img, bbox, label, score, label_names=self.label_names) fig = plt.gcf() fig.canvas.draw() w, h = fig.canvas.get_width_height() img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8) fig.clf() img.shape = (h, w, 3) plt.close() try: msg = self.cv_bridge.cv2_to_imgmsg(img, "rgb8") except Exception as e: rospy.logerr("Failed to convert bbox image: %s" % str(e)) return self.pub_image.publish(msg)
def main(): chainer.config.train = False parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model') parser.add_argument('image') parser.add_argument( '--label_names', help='The path to the yaml file with label names') args = parser.parse_args() with open(args.label_names, 'r') as f: label_names = tuple(yaml.load(f)) model = SSD300( n_fg_class=len(label_names), pretrained_model=args.pretrained_model) # Change the threshold for showing labels #model.score_thresh=0.55 if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] nb_containers = sum([1 for l in label if label_names[int(l)] == 'container']) a = vis_bbox( img, bbox, label, score, label_names=label_names) a.annotate("Number of containers = {}".format(nb_containers), xytext=(0,0), xy=(0,0)) plot.show()
def annotate(args, path_in, path_out): chainer.config.train = False with open("model/label_names_coco_container.yml", 'r') as f: label_names = tuple(yaml.load(f)) model = SSD300( n_fg_class=len(label_names), pretrained_model=args.model) # Change the threshold for showing labels # model.score_thresh=0.4 # model.nms_thres = args.threshold count = 1 numfiles = len([f for f in os.listdir(path_in) if ".jpg" in f]) for file in [f for f in os.listdir(path_in) if ".jpg" in f]: img = utils.read_image(path_in+file, color=True) bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] nb_containers = sum([1 for l in label if label_names[int(l)] == 'container']) a = vis_bbox( img, bbox, label, score, label_names=label_names) a.annotate("Number of containers = {}".format(nb_containers), xytext=(0, 0), xy=(0, 0)) plot.axis('off') plot.savefig(path_out + "frame{}.png".format(str(count).zfill(5)), bbox_inches='tight') plot.close() if count % 10 == 0: print("Progress: %0.2f%%" % (count / numfiles * 100,), flush=True) count += 1
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='sbd') parser.add_argument('image') args = parser.parse_args() model = FCISPSROIAlignResNet101(n_fg_class=20, pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = read_image(args.image, color=True) masks, labels, scores = model.predict([img]) mask, label, score = masks[0], labels[0], scores[0] bbox = mask_to_bbox(mask) colors = voc_colormap(list(range(1, len(mask) + 1))) ax = vis_bbox(img, bbox, instance_colors=colors, alpha=0.5, linewidth=1.5) vis_instance_segmentation( None, mask, label, score, label_names=sbd_instance_segmentation_label_names, instance_colors=colors, alpha=0.7, ax=ax) plt.show()
def publish_bbox_image(self, img, bbox, label, score): vis_bbox(img, bbox, label, score, label_names=self.label_names) fig = plt.gcf() fig.canvas.draw() w, h = fig.canvas.get_width_height() img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8) fig.clf() img.shape = (h, w, 3) plt.close() try: msg = self.cv_bridge.cv2_to_imgmsg(img, "rgb8") except Exception as e: rospy.logerr("Failed to convert bbox image: %s" % str(e)) return self.pub_image.publish(msg)
def visualize_dataset(config): from matplotlib import pyplot as plt dataset = select_dataset(config, return_data=["train_set"]) hand_class = config.get('model_param', 'hand_class').split(",") hand_class = [k.strip() for k in hand_class] class_converter, flip_converter = create_converter(hand_class) logger.info("hand_class = {}".format(hand_class)) logger.info("done get dataset") idx = random.randint(0, len(dataset) - 1) logger.info("get example") rgb, rgb_bbox, rgb_class = dataset.get_example(idx) logger.info("Done get example") fig = plt.figure(figsize=(5, 10)) ax1 = fig.add_subplot(211) ax2 = fig.add_subplot(212) label = rgb_class class_converter = {v: k for k, v in class_converter.items()} color = [COLOR_MAP[class_converter[c]] for c in label] print(label) vis_bbox( rgb, rgb_bbox, instance_colors=color, label=label, label_names=hand_class, ax=ax1, ) model = create_ssd_model() transform_dataset = TransformDataset( dataset, Transform(model.coder, model.insize, model.mean, train=True)) img, mb_loc, mb_label = transform_dataset.get_example(idx) mb_color = [COLOR_MAP[class_converter[c]] for c in mb_label] vis_bbox( img, mb_loc, instance_colors=mb_color, label=mb_label, label_names=hand_class, ax=ax2, ) plt.savefig("vis.png") plt.show()
def box_alignment(self, img, old_boxes, new_boxes, Spixels, contours, new_superset, save=True, path=None ): """ Visualize the change in the bboxes after box alignment Args: img : Input image old_boxes: Old bboxes new_boxes: Updated bboxes Spixels : set of superpixels """ # fig = plt.figure(figsize=(16, 7)) fig = plt.figure() ax1 = fig.add_subplot(221) plt.xticks([]) plt.yticks([]) plt.title('Superpixels') plt.imshow(contours) ax1 = fig.add_subplot(222) plt.xticks([]) plt.yticks([]) plt.title('Original box') vis_bbox(img, old_boxes, ax=ax1, linewidth=1.0) ax1 = fig.add_subplot(223) plt.xticks([]) plt.yticks([]) plt.title('Superpixels added') plt.imshow(new_superset[0]) ax2 = fig.add_subplot(224) plt.xticks([]) plt.yticks([]) plt.title('After box-align') vis_bbox(img, new_boxes, ax=ax2, linewidth=1.0) for spixel in Spixels: plt.imshow(spixel, cmap='gray', alpha=0.5, interpolation='none') if save: if path is None: raise ValueError('Path should be set') plt.savefig(path+'.png') else: plt.show() plt.close(fig)
def test_vis_bbox(self): if not optional_modules: return ax = vis_bbox( self.img, self.bbox, self.label, self.score, label_names=self.label_names) self.assertIsInstance(ax, matplotlib.axes.Axes)
def save_images(image_path, model, out_root, label_names): image_path_list = [x for x in glob.glob(os.path.join(image_path, '*.jpg'))] image_path_list += [ x for x in glob.glob(os.path.join(image_path, '*.png')) ] if not os.path.exists(out_root): os.mkdir(out_root) fig, ax = plt.subplots() for _img in image_path_list: img = chainercv.utils.read_image(_img, color=True) with chainer.using_config('train', False): bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] logger.info("{} {} {}".format(bbox, label, score)) vis_bbox(img, bbox, label, score, label_names=label_names, ax=ax) f_name = os.path.join(out_root, os.path.basename(_img)) plt.savefig(f_name) ax.clear()
def visualize_cb(self, event): if (not self.visualize or self.img is None or self.header is None or self.bboxes is None or self.labels is None or self.scores is None): return with self.lock: img = self.img.copy() header = copy.deepcopy(self.header) bboxes = self.bboxes.copy() labels = self.labels.copy() scores = self.scores.copy() fig = plt.figure(tight_layout={'pad': 0}) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.axis('off') fig.add_axes(ax) vis_bbox(img.transpose((2, 0, 1)), bboxes, labels, scores, label_names=self.label_names, ax=ax) fig.canvas.draw() w, h = fig.canvas.get_width_height() vis_img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8) vis_img.shape = (h, w, 3) fig.clf() plt.close() if self.pub_image.get_num_connections() > 0: vis_msg = self.bridge.cv2_to_imgmsg(vis_img, 'rgb8') # BUG: https://answers.ros.org/question/316362/sensor_msgsimage-generates-float-instead-of-int-with-python3/ # NOQA vis_msg.step = int(vis_msg.step) vis_msg.header = header self.pub_image.publish(vis_msg) if self.pub_image_compressed.get_num_connections() > 0: # publish compressed http://wiki.ros.org/rospy_tutorials/Tutorials/WritingImagePublisherSubscriber # NOQA vis_compressed_msg = CompressedImage() vis_compressed_msg.header = header vis_compressed_msg.format = "jpeg" vis_img_rgb = cv2.cvtColor(vis_img, cv2.COLOR_BGR2RGB) vis_compressed_msg.data = np.array( cv2.imencode('.jpg', vis_img_rgb)[1]).tostring() self.pub_image_compressed.publish(vis_compressed_msg)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', choices=('ssd300', 'ssd512'), default='ssd300') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained', default='./models/model_iter_12000.npz') args = parser.parse_args() label_names = pose_bbox_label_names BboxDataset = PoseBboxDataset if args.model == 'ssd300': model = SSD300(n_fg_class=len(label_names), pretrained_model=args.pretrained) elif args.model == 'ssd512': model = SSD512(n_fg_class=len(label_names), pretrained_model=args.pretrained) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() for i in range(0, 10): dataset = BboxDataset(split='test') ori_img, ori_bbox, ori_label = dataset[i] pred_bbox, pred_labels, pred_scores = model.predict([ori_img]) fig = plt.figure(figsize=(20, 10), dpi=80) fig.suptitle("Original vs Prediction Annotations", fontsize=32) ax1 = fig.add_subplot(1, 2, 1) ax1.set_xlabel("Original", fontsize=24) ax2 = fig.add_subplot(1, 2, 2) ax2.set_xlabel("Prediction", fontsize=24) vis_bbox(ori_img, ori_bbox, ori_label, label_names=label_names, ax=ax1) vis_bbox(ori_img, pred_bbox[0], pred_labels[0], pred_scores[0], label_names=label_names, ax=ax2) plt.tight_layout() plt.savefig('visualization/compare-{}.png'.format(i))
def test_vis_bbox(self): ax = vis_bbox(self.img, self.bbox, self.label, self.score, label_names=self.label_names, instance_colors=self.instance_colors, sort_by_score=self.sort_by_score) self.assertIsInstance(ax, matplotlib.axes.Axes)
def vis_pred_gt_bboxes(image, pred_bbox, gt_bbox, ax=None, show_iou=True): """Visualize both prediction and GT bboxes. The colors of prediction and GT bboxes are red and green, respectively. Args: image (~np.ndarray): Greyscale image of shape (H, W). pred_bbox (~np.ndarray): Prediction bbox of shape (R, 4). gt_bbox (~np.ndarray): GT bbox of shape (R', 4). ax (matplotlib.axes.Axis): The visualization is displayed on this axis. If this is :obj:`None` (default), a new axis is created. show_iou (bool): If `True`, show maximum IoU for each prediction bbox. Returns: ~matploblib.axes.Axes: Returns the Axes object with the plot for further tweaking. """ image = np.repeat([image], 3, axis=0) # (3, H, W) if show_iou and len(pred_bbox) > 0 and len(gt_bbox) > 0: iou = chainercv.utils.bbox_iou(pred_bbox, gt_bbox) iou = iou.max(axis=1) label_names = ['%.3f' % x for x in iou] label = range(len(label_names)) else: label_names, label = None, None ax = vis_bbox(image, pred_bbox, label=label, linewidth=1, ax=ax, label_names=label_names) transp_image = np.zeros((4, *image.shape[1:]), dtype=np.float32) ax = vis_bbox(transp_image, gt_bbox, instance_colors=((0, 255, 0), ), ax=ax, linewidth=1) return ax
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--model', choices=('yolo_v2', 'yolo_v2_tiny', 'yolo_v3'), default='yolo_v2') parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained-model', default='voc0712') parser.add_argument('--export', action='store_true') parser.add_argument('image') args = parser.parse_args() if args.model == 'yolo_v2': model = YOLOv2( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'yolo_v2_tiny': model = YOLOv2Tiny( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) elif args.model == 'yolo_v3': model = YOLOv3( n_fg_class=len(voc_bbox_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() img = utils.read_image(args.image, color=True) if args.export: import onnx_chainer x = model.xp.stack([img]) onnx_chainer.export_testcase(model, x, args.model) return bboxes, labels, scores = model.predict([img]) bbox, label, score = bboxes[0], labels[0], scores[0] vis_bbox( img, bbox, label, score, label_names=voc_bbox_label_names) plt.show()
if __name__ == '__main__': from chainercv.visualizations import vis_bbox from chainercv.visualizations import vis_semantic_segmentation from chainercv.chainer_experimental.datasets.sliceable import TransformDataset import matplotlib.pyplot as plt import numpy as np voc_segm = VOCSemanticSegmentationWithBboxDataset( split='aug') dataset = VOCSemanticSegmentationWithBboxDataset( split='aug').slice[:, ['img', 'bbox', 'label']] # transformed = TransformDataset( # dataset, ('img', 'label_map'), grabcut_transform) transformed = TransformDataset( dataset, ('img', 'label_map'), SimpleDoesItTransform()) indices = np.random.choice(np.arange(len(voc_segm)), size=(10,)) for index in indices: img, label_map, bbox, label = voc_segm[index] vis_bbox(img, bbox, label) plt.show() # see doc for better visualization vis_semantic_segmentation(img, label_map) plt.show() img, label_map = transformed[index] vis_semantic_segmentation(img, label_map, alpha=0.6, ignore_label_color=(255, 0, 0)) plt.show()