def __init__(self):
self.images = [
visuals.Image(image, method='impostor') for i in range(4)
]
self.images[0].transform = (
STTransform(scale=(30, 30), translate=(600, 600)) *
SineTransform() *
STTransform(scale=(0.1, 0.1), translate=(-5, -5)))
tr = AffineTransform()
tr.rotate(30, (0, 0, 1))
tr.scale((3, 3))
self.images[1].transform = (STTransform(translate=(200, 600)) * tr *
STTransform(translate=(-50, -50)))
self.images[2].transform = (
STTransform(scale=(3, -150), translate=(200, 100)) * LogTransform(
(0, 2, 0)) *
STTransform(scale=(1, -0.01), translate=(-50, 1.3)))
self.images[3].transform = (
STTransform(scale=(400, 400), translate=(600, 300)) *
PolarTransform() * STTransform(scale=(np.pi / 200, 0.005),
translate=(-3 * np.pi / 4., 0.1)))
vispy.scene.SceneCanvas.__init__(self, keys='interactive')
self.size = (800, 800)
self.show()
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive',
show=True,
size=self.canvas_size)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# laserscan part
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.scan_view.camera = vispy.scene.TurntableCamera(elevation=30,
azimuth=-90,
distance=30,
translate_speed=30,
up='+z')
# grid
self.grid = self.canvas.central_widget.add_grid()
self.grid.add_widget(self.scan_view)
self.scan_vis = visuals.Markers(parent=self.scan_view.scene)
self.scan_vis.antialias = 0
# self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
self.line = visuals.Line(width=1,
method='gl',
parent=self.scan_view.scene)
self.text = visuals.Text(color='red',
font_size=600,
bold=True,
parent=self.scan_view.scene)
self.gt_line = visuals.Line(width=1000, parent=self.scan_view.scene)
# self.sem_view.camera.link(self.scan_view.camera)
if self.show_img:
# img canvas size
# new canvas for img
self.img_canvas = SceneCanvas(keys='interactive',
show=True,
size=(1242, 375))
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
def __init__(self, parent=None):
"""Init."""
# Add PanZoom cameras to each box :
parent['Sagit'].camera = scene.PanZoomCamera()
parent['Coron'].camera = scene.PanZoomCamera()
parent['Axial'].camera = scene.PanZoomCamera()
# Define three images (Sagittal, Coronal, Axial) :
kwargs_im = {'interpolation': 'bilinear'}
self._cspSagit = visu.Image(name='SagitSplit', **kwargs_im)
self._cspCoron = visu.Image(name='CoronSplit', **kwargs_im)
self._cspAxial = visu.Image(name='AxialSplit', **kwargs_im)
# Define three text object :
kwargs_txt = {
'color': 'white',
'font_size': 2,
'anchor_x': 'left',
'anchor_y': 'bottom'
}
self._cspTxtSagit = visu.Text(text='Sagit', **kwargs_txt)
self._cspTxtCoron = visu.Text(text='Coron', **kwargs_txt)
self._cspTxtAxial = visu.Text(text='Axial', **kwargs_txt)
# Add each image to parent :
parent['Sagit'].add(self._cspSagit)
parent['Coron'].add(self._cspCoron)
parent['Axial'].add(self._cspAxial)
# Add text to parent :
parent['Sagit'].add(self._cspTxtSagit)
parent['Coron'].add(self._cspTxtCoron)
parent['Axial'].add(self._cspTxtAxial)
# Add transformations :
r90 = vist.MatrixTransform()
r90.rotate(90, (0, 0, 1))
r180 = vist.MatrixTransform()
r180.rotate(180, (0, 0, 1))
self._cspSagit.transform = r90
self._cspCoron.transform = r90
self._cspAxial.transform = r180
self._parent_sp = parent
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive', show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# 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_vis = visuals.Markers()
self.scan_view.camera = 'turntable'
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
# img canvas size
self.multiplier = 1
self.canvas_W = 1024
self.canvas_H = 64
# new canvas for img
self.img_canvas = SceneCanvas(keys='interactive', show=True,
size=(self.canvas_W, self.canvas_H * self.multiplier))
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
def __init__(self,
pic_xyz=None,
pic_data=None,
pic_dxyz=(0., 0., 1.),
pic_width=7.,
pic_height=7.,
pic_select=None,
pic_cmap='viridis',
pic_clim=None,
pic_vmin=None,
pic_vmax=None,
pic_under='gray',
pic_over='red',
**kwargs):
"""Init."""
if (pic_xyz is not None) and (pic_data is not None):
# Get (min, max) :
self._minmax = (pic_data.min(), pic_data.max())
# Define clim :
clim = pic_clim if pic_clim is not None else self._minmax
# Create the mesh :
self.mesh = PicMesh(pic_data,
pic_xyz,
width=pic_width,
height=pic_height,
dxyz=pic_dxyz,
select=pic_select,
name='Pictures',
clim=clim,
cmap=pic_cmap,
vmin=pic_vmin,
vmax=pic_vmax,
under=pic_under,
over=pic_over)
else:
self.mesh = visu.Image(name='NonePic')
clim = (0., 1.)
# Vmin/Vmax only active if not None and in [clim[0], clim[1]] :
isvmin = (pic_vmin is not None) and (clim[0] < pic_vmin < clim[1])
isvmax = (pic_vmax is not None) and (clim[0] < pic_vmax < clim[1])
# Initialize colorbar elements :
CbarArgs.__init__(self, pic_cmap, clim, isvmin, pic_vmin, isvmax,
pic_vmax, pic_under, pic_over)
line = visuals.Line(pos, color='white', parent=vb1.scene)
line.transform = STTransform(translate=(0, 0, -0.1))
grid1 = visuals.GridLines(parent=vb1.scene)
vb1.camera = Magnify1DCamera(mag=4, size_factor=0.6, radius_ratio=0.6)
vb1.camera.rect = 0, 30, 100000, 100
#
# Bottom-left viewbox: Image with circular magnification lens.
#
size = (100, 100)
img_data = np.random.normal(size=size + (3, ), loc=58,
scale=20).astype(np.ubyte)
image = visuals.Image(img_data, parent=vb2.scene, method='impostor')
vb2.camera = MagnifyCamera(mag=3, size_factor=0.3, radius_ratio=0.6)
vb2.camera.rect = (-10, -10, size[0] + 20, size[1] + 20)
#
# Bottom-right viewbox: Scatter plot with many clusters of varying scale.
#
centers = np.random.normal(size=(50, 2))
pos = np.random.normal(size=(100000, 2), scale=0.2)
indexes = np.random.normal(size=100000,
loc=centers.shape[0] / 2.,
scale=centers.shape[0] / 3.)
indexes = np.clip(indexes, 0, centers.shape[0] - 1).astype(int)
scales = 10**(np.linspace(-2, 0.5, centers.shape[0]))[indexes][:, np.newaxis]
pos *= scales
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 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)
def __init__(self,
xyz=None,
channels=None,
system='cartesian',
unit='degree',
title=None,
title_color='black',
title_size=20.,
line_color='black',
line_width=4.,
chan_size=12.,
chan_offset=(0., 0., 0.),
chan_mark_color='white',
chan_mark_symbol='disc',
chan_txt_color='black',
bgcolor='white',
cbar=True,
cb_txt_size=10.,
margin=.05,
parent=None):
"""Init."""
# ======================== VARIABLES ========================
self._bgcolor = color2vb(bgcolor)
scale = 800. # fix GL bugs for small plots
pos = np.zeros((1, 3), dtype=np.float32)
# Colors :
title_color = color2vb(title_color)
line_color = color2vb(line_color)
chan_txt_color = color2vb(chan_txt_color)
self._chan_mark_color = color2vb(chan_mark_color)
self._chan_mark_symbol = chan_mark_symbol
# Disc interpolation :
self._interp = .1
self._pix = 64
csize = int(self._pix / self._interp) if self._interp else self._pix
l = csize / 2 # noqa
# ======================== NODES ========================
# Main topoplot node :
self.node = scene.Node(name='Topoplot', parent=parent)
self.node.transform = vist.STTransform(scale=[scale] * 3)
# Headset + channels :
self.node_headfull = scene.Node(name='HeadChan', parent=self.node)
# Headset node :
self.node_head = scene.Node(name='Headset', parent=self.node_headfull)
# Channel node :
self.node_chan = scene.Node(name='Channels', parent=self.node_headfull)
self.node_chan.transform = vist.STTransform(translate=(0., 0., -10.))
# Cbar node :
self.node_cbar = scene.Node(name='Channels', parent=self.node)
# Dictionaries :
kw_line = {
'width': line_width,
'color': line_color,
'parent': self.node_head
}
# ======================== PARENT VISUALS ========================
# Main disc :
self.disc = visuals.Image(pos=pos,
name='Disc',
parent=self.node_head,
interpolation='bilinear')
# Title :
self.title = visuals.Text(text=title,
pos=(0., .6, 0.),
name='Title',
parent=self.node,
font_size=title_size,
color=title_color,
bold=True)
self.title.font_size *= 1.1
# ======================== HEAD / NOSE / EAR ========================
# ------------------ HEAD ------------------
# Head visual :
self.head = visuals.Line(pos=pos, name='Head', **kw_line)
# Head circle :
theta = np.arange(0, 2 * np.pi, 0.001)
head = np.full((len(theta), 3), -1., dtype=np.float32)
head[:, 0] = l * (1. + np.cos(theta))
head[:, 1] = l * (1. + np.sin(theta))
self.head.set_data(pos=head)
# ------------------ NOSE ------------------
# Nose visual :
self.nose = visuals.Line(pos=pos, name='Nose', **kw_line)
# Nose data :
wn, hn = csize * 50. / 512., csize * 30. / 512.
nose = np.array([[l - wn, 2 * l - wn, 2.], [l, 2 * l + hn, 2.],
[l, 2 * l + hn, 2.], [l + wn, 2 * l - wn, 2.]])
self.nose.set_data(pos=nose, connect='segments')
# ------------------ EAR ------------------
we, he = csize * 10. / 512., csize * 30. / 512.
ye = l + he * np.sin(theta)
# Ear left data :
self.earL = visuals.Line(pos=pos, name='EarLeft', **kw_line)
# Ear left visual :
ear_l = np.full((len(theta), 3), 3., dtype=np.float32)
ear_l[:, 0] = 2 * l + we * np.cos(theta)
ear_l[:, 1] = ye
self.earL.set_data(pos=ear_l)
# Ear right visual :
self.earR = visuals.Line(pos=pos, name='EarRight', **kw_line)
# Ear right data :
ear_r = np.full((len(theta), 3), 3., dtype=np.float32)
ear_r[:, 0] = 0. + we * np.cos(theta)
ear_r[:, 1] = ye
self.earR.set_data(pos=ear_r)
# ================== CHANNELS ==================
# Channel's markers :
self.chanMarkers = visuals.Markers(pos=pos,
name='ChanMarkers',
parent=self.node_chan)
# Channel's text :
self.chanText = visuals.Text(pos=pos,
name='ChanText',
parent=self.node_chan,
anchor_x='center',
color=chan_txt_color,
font_size=chan_size)
# ================== CAMERA ==================
self.rect = ((-scale / 2) * (1 + margin), (-scale / 2) * (1 + margin),
scale * (1. + cbar * .3 + margin),
scale * (1.11 + margin))
# ================== CBAR ==================
if cbar:
self.cbar = CbarVisual(cbtxtsz=1.2 * cb_txt_size,
txtsz=cb_txt_size,
txtcolor=title_color,
cbtxtsh=2.,
parent=self.node_cbar)
self.node_cbar.transform = vist.STTransform(scale=(.6, .4, 1.),
translate=(.6, 0., 0.))
# ================== COORDINATES ==================
auto = self._get_channel_coordinates(xyz, channels, system, unit)
if auto:
eucl = np.sqrt(self._xyz[:, 0]**2 + self._xyz[:, 1]**2).max()
self.node_head.transform = vpnormalize(head, dist=2 * eucl)
# Rescale between (-1:1, -1:1) = circle :
circle = vist.STTransform(scale=(.5 / eucl, .5 / eucl, 1.))
self.node_headfull.transform = circle
# Text translation :
tr = np.array([0., .8, 0.]) + np.array(chan_offset)
else:
# Get coordinates of references along the x and y-axis :
ref_x, ref_y = self._get_ref_coordinates()
# Recenter the topoplot :
t = vist.ChainTransform()
t.prepend(vprecenter(head))
# Rescale (-ref_x:ref_x, -ref_y:ref_y) (ref_x != ref_y => ellipse)
coef_x = 2 * ref_x / head[:, 0].max()
coef_y = 2 * ref_y / head[:, 1].max()
t.prepend(vist.STTransform(scale=(coef_x, coef_y, 1.)))
self.node_head.transform = t
# Rescale between (-1:1, -1:1) = circle :
circle = vist.STTransform(scale=(.5 / ref_x, .5 / ref_y, 1.))
self.node_headfull.transform = circle
# Text translation :
tr = np.array([0., .04, 0.]) + np.array(chan_offset)
self.chanText.transform = vist.STTransform(translate=tr)
# ================== GRID INTERPOLATION ==================
# Interpolation vectors :
x = y = np.arange(0, self._pix, 1)
xnew = ynew = np.arange(0, self._pix, self._interp)
# Grid interpolation function :
def _grid_interpolation(grid):
f = interp2d(x, y, grid, kind='linear')
return f(xnew, ynew)
self._grid_interpolation = _grid_interpolation
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys="interactive", show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# 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_vis = visuals.Markers()
self.scan_view.camera = "turntable"
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
# add semantics
if self.semantics:
print("Using semantics in visualizer")
self.sem_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.canvas.scene
)
self.grid.add_widget(self.sem_view, 0, 1)
self.sem_vis = visuals.Markers()
self.sem_view.camera = "turntable"
self.sem_view.add(self.sem_vis)
visuals.XYZAxis(parent=self.sem_view.scene)
self.sem_view.camera.link(self.scan_view.camera)
if self.instances:
print("Using instances in visualizer")
self.inst_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.canvas.scene
)
self.grid.add_widget(self.inst_view, 0, 2)
self.inst_vis = visuals.Markers()
self.inst_view.camera = "turntable"
self.inst_view.add(self.inst_vis)
visuals.XYZAxis(parent=self.inst_view.scene)
# self.inst_view.camera.link(self.scan_view.camera)
# img canvas size
self.multiplier = 1
self.canvas_W = 1024
self.canvas_H = 64
if self.semantics:
self.multiplier += 1
if self.instances:
self.multiplier += 1
# new canvas for img
self.img_canvas = SceneCanvas(
keys="interactive",
show=True,
size=(self.canvas_W, self.canvas_H * self.multiplier),
)
# grid
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, b back, q quit, very simple)
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add a view for the depth
self.img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.img_view, 0, 0)
self.img_vis = visuals.Image(cmap="viridis")
self.img_view.add(self.img_vis)
# add semantics
if self.semantics:
self.sem_img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.sem_img_view, 1, 0)
self.sem_img_vis = visuals.Image(cmap="viridis")
self.sem_img_view.add(self.sem_img_vis)
# add instances
if self.instances:
self.inst_img_view = vispy.scene.widgets.ViewBox(
border_color="white", parent=self.img_canvas.scene
)
self.img_grid.add_widget(self.inst_img_view, 2, 0)
self.inst_img_vis = visuals.Image(cmap="viridis")
self.inst_img_view.add(self.inst_img_vis)
def __init__(self, parent=None, **kwargs):
"""Init."""
# _____________________ INIT _____________________
self._n = 1000
self._ratio = 4 / 5
CbarBase.__init__(self, **kwargs)
# _____________________ CANVAS _____________________
if parent is None:
# Define a canvas :
self._canvas = scene.SceneCanvas(keys='interactive',
show=False,
resizable=True,
dpi=600,
bgcolor=self._bgcolor,
size=(300, 900))
self._wc = self._canvas.central_widget.add_view()
parent = self._wc.scene
# Define the camera :
self._camera = FixedCam(rect=(-1.2, -1.2, 2.4, 2.4))
self._wc.camera = self._camera
self.parent = parent
# _____________________ OBJECTS _____________________
# --------------------- Node ---------------------
# Define node parent and limit node :
self._cbNode = Node(name='Colorbar', parent=parent)
self._limNode = Node(name='Limits', parent=self._cbNode)
# Rescale between (-1., 1.) :
self._rsc = vist.STTransform(scale=(self._width, 2 / self._n, 1),
translate=(0, -1., 0))
# Set transformation to the node :
self._cbNode.transform = self._rsc
# --------------------- Image ---------------------
self._mImage = visuals.Image(parent=self._cbNode, name='image')
# --------------------- Border ---------------------
pos = np.array([[0., 0., -3.], [1., 0., -3.], [1., 0., -3.],
[1., self._n, -3.], [1., self._n, -3.],
[0., self._n, -3.], [0., self._n, -3.], [0., 0., -3.]])
self._mBorder = visuals.Line(parent=self._cbNode, name='Border')
self._mBorder.set_data(pos=pos,
width=2.,
connect='segments',
color=self._txtcolor)
self._mBorder.visible = self._border
# --------------------- Labels ---------------------
# Clim labels :
self._mClimM = visuals.Text(parent=self._limNode,
color=self._txtcolor,
font_size=self._txtsz,
name='Clim_M',
anchor_x='left')
self._mClimm = visuals.Text(parent=self._limNode,
color=self._txtcolor,
font_size=self._txtsz,
name='Clim_m',
anchor_x='left')
# Cblabel :
self._mcblabel = visuals.Text(parent=self._limNode,
name='Cblabel',
color=self._txtcolor,
anchor_x='center',
font_size=self._cbtxtsz)
self._mcblabel.rotation = -90
# Vmin/Vmax :
self._vmMNode = Node(name='VminVmax', parent=self._limNode)
self._mVm = visuals.Text(parent=self._vmMNode,
color=self._txtcolor,
font_size=self._ratio * self._txtsz,
name='Vmin',
anchor_x='left')
self._mVM = visuals.Text(parent=self._vmMNode,
color=self._txtcolor,
font_size=self._ratio * self._txtsz,
name='Vmax',
anchor_x='left')
# Build colorbar :
self._build(True, 'all')
def pcd_vispy_standard(scans=None,
img=None,
boxes=None,
name=None,
index=0,
vis_size=(800, 600),
save_img=False,
visible=True,
multi_vis=False,
point_size=0.02,
lidar_view_set=None):
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)
if lidar_view_set is None:
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
else:
vb.camera = 'turntable'
vb.camera.elevation = lidar_view_set['elevation'] # 21.0
vb.camera.center = lidar_view_set['center']
vb.camera.azimuth = lidar_view_set['azimuth']
vb.camera.scale_factor = lidar_view_set['scale_factor']
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=0.1,
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 = (1900, 160, -1300)
vb_img.camera.azimuth = 0.0
vb_img.camera.scale_factor = 1500
vb_img.add(image)
if boxes is not None:
if len(boxes.shape) == 1:
boxes = boxes.reshape(-1, boxes.shape[0])
# one box: type,xyz,lwh,yaw,[score,reserve1,reserve2]
for box in boxes:
if box[0] == 1: # type:car
vb.add(line_box_stand(box, color="yellow"))
elif box[0] == 2: # type:Perdestrain
vb.add(line_box_stand(box, color="red"))
elif box[0] == 3: # type:Cyclist
vb.add(line_box_stand(box, color="blue"))
elif box[0] == 4: # type:Van
vb.add(line_box_stand(box, color="pink"))
else:
vb.add(line_box_stand(box, color="green"))
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 __init__(self):
self.image = visuals.Image(image, method='subdivide')
self.image.transform = STTransform(scale=(7, 7), translate=(50, 50))
vispy.scene.SceneCanvas.__init__(self, keys='interactive')
self.size = (800, 800)
self.show()
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
''' 3D points cloud or mesh SceneCanvas '''
# new canvas prepared for visualizing data
self.canvas = SceneCanvas(keys='interactive', show=True)
# interface (n next, b back, q quit, very simple)
self.canvas.events.key_press.connect(self.key_press)
self.canvas.events.draw.connect(self.draw)
# grid
self.grid = self.canvas.central_widget.add_grid()
# add point cloud views
self.scan_view = vispy.scene.widgets.ViewBox(border_color='white',
parent=self.canvas.scene)
self.grid.add_widget(self.scan_view, 0, 0)
# Camera location settings
self.scene_cam = vispy.scene.cameras.BaseCamera()
# self.scene_cam.center = (-10, -10, 10)
# self.scan_view.add(self.scene_cam)
# self.scene_cam.pre_transform.set_range()
canvas2 = vispy.app.Canvas()
w = QMainWindow()
widget = QWidget()
w.setCentralWidget(widget)
widget.setLayout(QVBoxLayout())
widget.layout().addWidget(canvas2.native)
widget.layout().addWidget(QPushButton())
w.show()
self.scan_vis = visuals.Mesh()
self.scan_vis_mean = visuals.Line()
self.scan_vis_cam = visuals.Line()
self.scan_bbox_3d = visuals.Line()
self.label_vis = visuals.Text()
self.scan_view.add(self.scan_vis)
self.scan_view.add(self.scan_vis_mean)
self.scan_view.add(self.scan_vis_cam)
self.scan_view.add(self.scan_bbox_3d)
self.scan_view.add(self.label_vis)
self.scan_view.camera = 'arcball'
self.tr = self.scan_vis.transforms.get_transform(map_from='visual',
map_to='canvas')
# self.scan_view.camera = self.scene_cam
# self.scan_view.camera = 'arcball' , 'turntable'
# self.scan_view.camera.transform.rotate(90, (0,1,0))
visuals.XYZAxis(parent=self.scan_view.scene)
''' 2D images SceneCanvas '''
# img canvas size
self.canvas_W = 320
self.canvas_H = 280
self.multiplier = 2
''' new canvas for RGB & Depth img '''
self.img_canvas = SceneCanvas(keys='interactive',
show=True,
size=(self.canvas_W,
self.canvas_H * self.multiplier))
self.img_grid = self.img_canvas.central_widget.add_grid()
# interface (n next, s start, p pause, q quit, )
self.img_canvas.events.key_press.connect(self.key_press)
self.img_canvas.events.draw.connect(self.draw)
# add rgb views
self.rgb_img_raw_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.rgb_img_raw_view, 0, 0)
self.rgb_img_raw_vis = visuals.Image(cmap='viridis')
self.rgb_img_raw_view.add(self.rgb_img_raw_vis)
# add a view for the depth
self.depth_img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.img_canvas.scene)
self.img_grid.add_widget(self.depth_img_view, 1, 0)
self.depth_img_vis = visuals.Image(cmap='viridis')
self.depth_img_view.add(self.depth_img_vis)
''' new canvas for 3D scene graph img '''
self.scene_graph_canvas = SceneCanvas(keys='interactive',
show=True,
size=(640, 480))
self.scene_graph_grid = self.scene_graph_canvas.central_widget.add_grid(
)
self.scene_graph_canvas.events.key_press.connect(self.key_press)
self.scene_graph_canvas.events.draw.connect(self.draw)
# add a view for 3D scene graphs
self.scene_graph_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scene_graph_canvas.scene)
self.scene_graph_grid.add_widget(self.scene_graph_view, 0, 0)
self.scene_graph_vis = visuals.Image(cmap='viridis')
self.scene_graph_view.add(self.scene_graph_vis)
def reset(self):
""" Reset. """
# last key press (it should have a mutex, but visualization is not
# safety critical, so let's do things wrong)
self.action = "no" # no, next, back, quit are the possibilities
# 3D canvas
self.scan_canvas = SceneCanvas(keys='interactive',
show=True,
title='',
size=(1600, 600),
bgcolor='white')
self.scan_canvas.events.key_press.connect(self.key_press)
self.grid_view = self.scan_canvas.central_widget.add_grid()
# source laserscan 3D
self.scan_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.scan_vis = visuals.Markers()
self.scan_view.camera = 'turntable'
self.scan_view.add(self.scan_vis)
visuals.XYZAxis(parent=self.scan_view.scene)
self.grid_view.add_widget(self.scan_view, 0, 0)
# target laserscan 3D
if self.show_target is True:
self.back_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.back_vis = visuals.Markers()
self.back_view.camera = 'turntable'
self.back_view.camera.link(self.scan_view.camera)
self.back_view.add(self.back_vis)
visuals.XYZAxis(parent=self.back_view.scene)
self.grid_view.add_widget(self.back_view, 0, 1)
# self.grid_view.padding = 6
# Set height of images
h = 1
if self.show_range is True:
h += 1
if self.show_remissions is True:
h += 1
# source canvas 2D
source_canvas_title = 'Source ' + str(self.H[0]) + 'x' + str(self.W[0])
self.source_canvas = SceneCanvas(keys='interactive',
show=True,
title=source_canvas_title,
size=(self.W[0], h * self.H[0]))
self.source_canvas.events.key_press.connect(self.key_press)
self.source_view = self.source_canvas.central_widget.add_grid()
source_grid_idx = 0
# Add label image
if self.show_label:
self.img_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.img_vis = visuals.Image(cmap='viridis')
self.img_view.add(self.img_vis)
self.source_view.add_widget(self.img_view, source_grid_idx, 0)
source_grid_idx += 1
# target canvas 2D
if self.show_target:
target_canvas_title = 'Target ' + str(self.H[1]) + 'x' + str(
self.W[1])
self.target_canvas = SceneCanvas(keys='interactive',
show=True,
title=target_canvas_title,
size=(self.W[1], h * self.H[1]))
self.target_canvas.events.key_press.connect(self.key_press)
self.target_view = self.target_canvas.central_widget.add_grid()
target_grid_idx = 0
# Add label image
if self.show_label:
self.test_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.test_vis = visuals.Image(cmap='viridis')
self.test_view.add(self.test_vis)
self.target_view.add_widget(self.test_view, target_grid_idx, 0)
target_grid_idx += 1
if self.show_range:
# Add source range image
self.range_view_source = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.range_image_source = visuals.Image()
self.range_view_source.add(self.range_image_source)
self.source_view.add_widget(self.range_view_source,
source_grid_idx, 0)
source_grid_idx += 1
if self.show_target:
self.range_view_target = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.range_image_target = visuals.Image(cmap='viridis')
self.range_view_target.add(self.range_image_target)
self.target_view.add_widget(self.range_view_target,
target_grid_idx, 0)
target_grid_idx += 1
if self.show_remissions:
# Add source remissions image
self.remissions_view_source = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.source_canvas.scene)
self.remissions_image_source = visuals.Image()
self.remissions_view_source.add(self.remissions_image_source)
self.source_view.add_widget(self.remissions_view_source,
source_grid_idx, 0)
source_grid_idx += 1
# Add target remissions image
if self.show_target:
self.remissions_view_target = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.target_canvas.scene)
self.remissions_image_target = visuals.Image(cmap='viridis')
self.remissions_view_target.add(self.remissions_image_target)
self.target_view.add_widget(self.remissions_view_target,
target_grid_idx, 0)
target_grid_idx += 1
# 2D canvas for showing difference in range, labels and remissions
if self.show_diff:
self.diff_canvas = SceneCanvas(keys='interactive',
show=True,
title='Difference Range Image',
size=(self.W[1], self.H[1] * h))
self.diff_canvas.events.key_press.connect(self.key_press)
self.diff_view = self.diff_canvas.central_widget.add_grid()
grid_idx = 0
# Add label difference
if self.show_label:
self.diff_view_label = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_label = visuals.Image(cmap='viridis')
self.diff_view_label.add(self.diff_image_label)
self.diff_view.add_widget(self.diff_view_label, grid_idx, 0)
grid_idx += 1
# Add range difference
if self.show_range:
self.diff_view_depth = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_depth = visuals.Image()
self.diff_view_depth.add(self.diff_image_depth)
self.diff_view.add_widget(self.diff_view_depth, grid_idx, 0)
grid_idx += 1
# Add remissions difference
if self.show_remissions:
self.diff_view_remissions = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.diff_canvas.scene)
self.diff_image_remissions = visuals.Image()
self.diff_view_remissions.add(self.diff_image_remissions)
self.diff_view.add_widget(self.diff_view_remissions, grid_idx,
0)
grid_idx += 1
if self.show_mesh:
self.mesh_view = vispy.scene.widgets.ViewBox(
border_color='white', parent=self.scan_canvas.scene)
self.mesh_vis = visuals.Mesh(shading=None)
self.mesh_view.camera = 'turntable'
self.mesh_view.camera.link(self.scan_view.camera)
self.mesh_view.add(self.mesh_vis)
visuals.XYZAxis(parent=self.mesh_view.scene)
self.grid_view.add_widget(self.mesh_view, 0, 2)
