def reset(self, sem_color_dict=None):
        """ Reset. """
        # new canvas prepared for visualizing data
        self.map_color(sem_color_dict=sem_color_dict)
        self.canvas = SceneCanvas(keys='interactive', show=True)
        # grid
        self.grid = self.canvas.central_widget.add_grid()

        # laserscan part
        self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
                                                     parent=self.canvas.scene)
        self.grid.add_widget(self.scan_view, 0, 0)
        self.scan_view.camera = 'turntable'

        self.scan_vis = visuals.Markers()
        self.scan_view.add(self.scan_vis)

        if self.viz_joint:
            self.joint_vis = visuals.Arrow(connect='segments',
                                           arrow_size=18,
                                           color='blue',
                                           width=10,
                                           arrow_type='angle_60')
            self.arrow_length = 10
            self.scan_view.add(self.joint_vis)
        if self.viz_box:
            vertices, faces, outline = create_box(width=1,
                                                  height=1,
                                                  depth=1,
                                                  width_segments=1,
                                                  height_segments=1,
                                                  depth_segments=1)
            vertices['color'][:, 3] = 0.2
            # breakpoint()
            self.box = visuals.Box(vertex_colors=vertices['color'],
                                   edge_color='b')
            self.box.transform = STTransform(translate=[-2.5, 0, 0])
            self.theta = 0
            self.phi = 0
            self.scan_view.add(self.box)
        visuals.XYZAxis(parent=self.scan_view.scene)

        # add nocs
        if self.viz_label:
            print("Using nocs in visualizer")
            self.nocs_view = vispy.scene.widgets.ViewBox(
                border_color='white', parent=self.canvas.scene)
            self.grid.add_widget(self.nocs_view, 0, 1)
            self.label_vis = visuals.Markers()
            self.nocs_view.camera = 'turntable'
            self.nocs_view.add(self.label_vis)
            visuals.XYZAxis(parent=self.nocs_view.scene)
            self.nocs_view.camera.link(self.scan_view.camera)
Beispiel #2
0
    def input_data(self,
                   scans=None,
                   img=None,
                   boxes=None,
                   index=0,
                   save_img=False,
                   no_gt=False):
        self.canvas = vispy.scene.SceneCanvas(show=True)
        self.grid = self.canvas.central_widget.add_grid()
        self.vb = self.grid.add_view(row=0, col=0, row_span=2)
        self.vb_img = self.grid.add_view(row=1, col=0)

        self.vb.camera = 'turntable'
        self.vb.camera.elevation = 90  #21.0
        self.vb.camera.center = (6.5, -0.5, 9.0)
        self.vb.camera.azimuth = -90  #-75.5
        self.vb.camera.scale_factor = 63  #32.7

        self.vb_img.camera = 'turntable'
        self.vb_img.camera.elevation = -90.0
        self.vb_img.camera.center = (2100, -380, -500)
        self.vb_img.camera.azimuth = 0.0
        self.vb_img.camera.scale_factor = 1500

        pos = scans[:, 0:3]
        scatter = visuals.Markers()
        scatter.set_gl_state('translucent', depth_test=False)
        scatter.set_data(pos,
                         edge_width=0,
                         face_color=(1, 1, 1, 1),
                         size=0.01,
                         scaling=True)
        self.vb.add(scatter)

        if img is None:
            img = np.zeros(shape=[1, 1, 3], dtype=np.float32)
        image = visuals.Image(data=img, method='auto')
        self.vb_img.add(image)

        if boxes is not None:
            if len(boxes.shape) == 1:
                boxes = boxes.reshape(1, -1)
            gt_indice = np.where(boxes[:, -1] == 2)[0]
            gt_cnt = len(gt_indice)
            i = 0
            for box in boxes:
                radio = max(box[0] - 0.5, 0.005) * 2.0
                color = (0, radio, 0, 1)  # Green

                if box[-1] == 4:  #  gt boxes
                    i = i + 1
                    vsp_box = visuals.Box(width=box[4],
                                          depth=box[5],
                                          height=box[6],
                                          color=(0.6, 0.8, 0.0,
                                                 0.3))  #edge_color='yellow')
                    mesh_box = vsp_box.mesh.mesh_data
                    mesh_border_box = vsp_box.border.mesh_data
                    vertices = mesh_box.get_vertices()
                    center = np.array([box[1], box[2], box[3]],
                                      dtype=np.float32)
                    vtcs = np.add(vertices, center)
                    mesh_border_box.set_vertices(vtcs)
                    mesh_box.set_vertices(vtcs)
                    self.vb.add(vsp_box)
                    if False:
                        text = visuals.Text(text='gt: ({}/{})'.format(
                            i, gt_cnt),
                                            color='white',
                                            face='OpenSans',
                                            font_size=12,
                                            pos=[box[1], box[2], box[3]],
                                            anchor_x='left',
                                            anchor_y='top',
                                            font_manager=None)
                        self.vb.add(text)

                if (box[-1] +
                        box[-2]) == 0:  # True negative cls rpn divided by cube
                    self.vb.add(line_box(box, color=color))
                if (box[-1] + box[-2]
                    ) == 1:  # False negative cls rpn divided by cube
                    self.vb.add(line_box(box, color='red'))
                if (box[-1] + box[-2]
                    ) == 2:  # False positive cls rpn divided by cube
                    if no_gt:
                        self.vb.add(line_box(box, color='yellow'))
                    else:
                        self.vb.add(line_box(box, color='blue'))
                if (box[-1] +
                        box[-2]) == 3:  # True positive cls rpn divided by cube
                    self.vb.add(line_box(box, color='yellow'))

        if save_img:
            if not os.path.exists(folder):
                os.makedirs(folder)
            fileName = path_add(folder, str(index).zfill(6) + '.png')
            res = self.canvas.render(bgcolor='black')[:, :, 0:3]
            vispy_file.write_png(fileName, res)

        @self.canvas.connect
        def on_key_press(ev):
            if ev.key.name in '+=':
                a = self.vb.camera.get_state()
            print(a)
Beispiel #3
0
def pcd_vispy(scans=None,
              img=None,
              boxes=None,
              name=None,
              index=0,
              vis_size=(800, 600),
              save_img=False,
              visible=True,
              no_gt=False,
              multi_vis=False,
              point_size=0.02):
    if multi_vis:
        canvas = vispy.scene.SceneCanvas(title=name,
                                         keys='interactive',
                                         size=vis_size,
                                         show=True)
    else:
        canvas = vispy.scene.SceneCanvas(title=name,
                                         keys='interactive',
                                         size=vis_size,
                                         show=visible)
    grid = canvas.central_widget.add_grid()
    vb = grid.add_view(row=0, col=0, row_span=2)
    vb_img = grid.add_view(row=1, col=0)

    vb.camera = 'turntable'
    vb.camera.elevation = 90  # 21.0
    vb.camera.center = (6.5, -0.5, 9.0)
    vb.camera.azimuth = -90  # -75.5
    vb.camera.scale_factor = 63  # 32.7

    if scans is not None:
        if not isinstance(scans, list):
            pos = scans[:, :3]
            scatter = visuals.Markers()
            scatter.set_gl_state('translucent', depth_test=False)
            scatter.set_data(pos,
                             edge_width=0,
                             face_color=(1, 1, 1, 1),
                             size=point_size,
                             scaling=True)
            vb.add(scatter)
        else:
            pos = scans[0][:, :3]
            scatter = visuals.Markers()
            scatter.set_gl_state('translucent', depth_test=False)
            scatter.set_data(pos,
                             edge_width=0,
                             face_color=(1, 1, 1, 1),
                             size=point_size,
                             scaling=True)
            vb.add(scatter)

            pos = scans[1][:, :3]
            scatter = visuals.Markers()
            scatter.set_gl_state('translucent', depth_test=False)
            scatter.set_data(pos,
                             edge_width=0,
                             face_color=(0, 1, 1, 1),
                             size=point_size,
                             scaling=True)
            vb.add(scatter)

    axis = visuals.XYZAxis()
    vb.add(axis)

    if img is None:
        img = np.zeros(shape=[1, 1, 3], dtype=np.float32)
    image = visuals.Image(data=img, method='auto')
    vb_img.camera = 'turntable'
    vb_img.camera.elevation = -90.0
    vb_img.camera.center = (2100, -380, -500)
    vb_img.camera.azimuth = 0.0
    vb_img.camera.scale_factor = 1500
    vb_img.add(image)

    if boxes is not None:
        gt_indice = np.where(boxes["cls_rpn"] == 4)[0]
        gt_cnt = len(gt_indice)
        boxes_cnt = boxes["center"].shape[0]
        i = 0
        for k in range(boxes_cnt):
            radio = max(boxes["score"][k] - 0.5, 0.005) * 2.0
            color = (0, radio, 0, 1)  # Green
            if boxes["cls_rpn"][k] == 4:  #  gt boxes
                i = i + 1
                vsp_box = visuals.Box(depth=boxes["size"][k][0],
                                      width=boxes["size"][k][1],
                                      height=boxes["size"][k][2],
                                      color=(0.3, 0.4, 0.0, 0.06),
                                      edge_color='pink')
                mesh_box = vsp_box.mesh.mesh_data
                mesh_border_box = vsp_box.border.mesh_data
                vertices = mesh_box.get_vertices()
                center = np.array([
                    boxes["center"][k][0], boxes["center"][k][1],
                    boxes["center"][k][2]
                ],
                                  dtype=np.float32)
                vertices_roa_trans = box_rot_trans(vertices,
                                                   -boxes["yaw"][k][0],
                                                   center)  #
                mesh_border_box.set_vertices(vertices_roa_trans)
                mesh_box.set_vertices(vertices_roa_trans)
                vb.add(vsp_box)
                if True:
                    text = visuals.Text(text='det: ({}/{})'.format(i, gt_cnt),
                                        color='white',
                                        face='OpenSans',
                                        font_size=12,
                                        pos=[
                                            boxes["center"][k][0],
                                            boxes["center"][k][1],
                                            boxes["center"][k][2]
                                        ],
                                        anchor_x='left',
                                        anchor_y='top',
                                        font_manager=None)
                    vb.add(text)
            elif (boxes["cls_rpn"][k] + boxes["cls_cube"][k]
                  ) == 0:  # True negative cls rpn divided by cube
                vb.add(
                    line_box(boxes["center"][k],
                             boxes["size"][k],
                             -boxes["yaw"][k],
                             color=color))
            elif (boxes["cls_rpn"][k] + boxes["cls_cube"][k]
                  ) == 1:  # False negative cls rpn divided by cube
                vb.add(
                    line_box(boxes["center"][k],
                             boxes["size"][k],
                             -boxes["yaw"][k],
                             color="red"))
            elif (boxes["cls_rpn"][k] + boxes["cls_cube"][k]
                  ) == 2:  # False positive cls rpn divided by cube
                vb.add(
                    line_box(boxes["center"][k],
                             boxes["size"][k],
                             -boxes["yaw"][k],
                             color="blue"))
            elif (boxes["cls_rpn"][k] + boxes["cls_cube"][k]
                  ) == 3:  # True positive cls rpn divided by cube
                vb.add(
                    line_box(boxes["center"][k],
                             boxes["size"][k],
                             -boxes["yaw"][k],
                             color="yellow"))
            text = visuals.Text(
                text=str(k),
                color=color,
                face='OpenSans',
                font_size=12,
                pos=[
                    boxes["center"][k][0] - boxes["size"][k][0] / 2,
                    boxes["center"][k][1] - boxes["size"][k][1] / 2,
                    boxes["center"][k][2] - boxes["size"][k][2] / 2
                ],
                anchor_x='left',
                anchor_y='top',
                font_manager=None)

            vb.add(text)

    if save_img:
        folder = path_add(cfg.TEST_RESULT, cfg.RANDOM_STR)
        if not os.path.exists(folder):
            os.makedirs(folder)
        fileName = path_add(folder, str(index).zfill(6) + '.png')
        res = canvas.render(bgcolor='black')[:, :, 0:3]
        vispy_file.write_png(fileName, res)

    @canvas.connect
    def on_key_press(ev):
        if ev.key.name in '+=':
            a = vb.camera.get_state()
            print(a)

    if visible:
        pass
        vispy.app.run()

    return canvas
def boxes_vispy(boxes=None, name=None, vis_size=(800, 600)):

    canvas = vispy.scene.SceneCanvas(title=name,
                                     keys='interactive',
                                     size=vis_size,
                                     show=True)

    grid = canvas.central_widget.add_grid()
    vb = grid.add_view(row=0, col=0, row_span=2)

    vb.camera = 'turntable'
    vb.camera.elevation = 21.0
    vb.camera.center = (6.5, -0.5, 9.0)
    vb.camera.azimuth = -75.5
    vb.camera.scale_factor = 32.7

    axis = visuals.XYZAxis()
    vb.add(axis)

    if boxes is not None:
        if len(boxes.shape) == 1:
            boxes = boxes.reshape(1, -1)

        det_indice = np.where(boxes[:, -1] == 11)[0]
        det_cnt = len(det_indice)

        gt_cnt = boxes.shape[0] - det_cnt

        for k, box in enumerate(boxes):
            color = (0, 1, 1, 1)  # Green
            if box[-1] == 11:  #  det boxes
                vsp_box = visuals.Box(width=box[3],
                                      depth=box[4],
                                      height=box[5],
                                      color=(0.3, 0.4, 0.0, 0.06),
                                      edge_color='pink')
                mesh_box = vsp_box.mesh.mesh_data
                mesh_border_box = vsp_box.border.mesh_data
                vertices = mesh_box.get_vertices()
                center = np.array([box[0], box[1], box[2]], dtype=np.float32)
                vtcs = np.add(vertices, center)
                mesh_border_box.set_vertices(vtcs)
                mesh_box.set_vertices(vtcs)
                vb.add(vsp_box)
                text = visuals.Text(text='det: ({}/{})'.format(k + 1, det_cnt),
                                    color='pink',
                                    face='OpenSans',
                                    font_size=6,
                                    pos=[box[0], box[1], box[2]],
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_manager=None)
                vb.add(text)
            elif box[-1] == 1:  # gt smallMot
                vb.add(line_box(box, color='yellow'))
                text = visuals.Text(text='gt: ({}/{})'.format(
                    k + 1 - det_cnt, gt_cnt),
                                    color='yellow',
                                    face='OpenSans',
                                    font_size=8,
                                    pos=[box[0], box[1], box[2]],
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_manager=None)
                vb.add(text)
            elif box[-1] == 2:  # gt smallMot
                vb.add(line_box(box, color='green'))
                text = visuals.Text(text='gt: ({}/{})'.format(
                    k + 1 - det_cnt, gt_cnt),
                                    color='green',
                                    face='OpenSans',
                                    font_size=8,
                                    pos=[box[0], box[1], box[2]],
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_manager=None)
                vb.add(text)
            elif box[-1] == 3:  # gt smallMot
                vb.add(line_box(box, color='red'))
                text = visuals.Text(text='gt: ({}/{})'.format(
                    k + 1 - det_cnt, gt_cnt),
                                    color='red',
                                    face='OpenSans',
                                    font_size=8,
                                    pos=[box[0], box[1], box[2]],
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_manager=None)
                vb.add(text)
            elif box[-1] == 4:  # gt smallMot
                vb.add(line_box(box, color='blue'))
                text = visuals.Text(text='gt: ({}/{})'.format(
                    k + 1 - det_cnt, gt_cnt),
                                    color='blue',
                                    face='OpenSans',
                                    font_size=8,
                                    pos=[box[0], box[1], box[2]],
                                    anchor_x='left',
                                    anchor_y='top',
                                    font_manager=None)
                vb.add(text)
            # text = visuals.Text(text=str(k), color=color, face='OpenSans', font_size=12,
            #                     pos=[box[0]-box[3]/2, box[1]-box[4]/2, box[2]-box[5]/2], anchor_x='left', anchor_y='top', font_manager=None)
            # vb.add(text)

    vispy.app.run()

    return canvas