def init_canvas(self):
if self.verbose == 1:
print('init_canvas')
app.use_app('ipynb_webgl')
ca = vispy.scene.SceneCanvas(keys='interactive', show=True,size=(self.canvas_width,self.canvas_height),bgcolor=[1,1,1])
ca.show()
self.canvas = ca
view = ca.central_widget.add_view()
self.text = visuals.Text(anchor_x='right')
view.add(self.text)
self.label_texts = visuals.Text(anchor_x='right')
view.add(self.label_texts)
self.camera = CustomPanZoomCamera([self.text,self.label_texts])
view.camera = self.camera
axis = visuals.Axis(parent=view.scene)
self.view = view
self.line = visuals.Line()
self.line.set_data(pos=np.array([[0,0,0]]),color=np.array([[0,0,0,0]]))
self.line.order = 1
self.view.add(self.line)
self.mesh = visuals.Mesh()
self.mesh.order = 0
self.view.add(self.mesh)
app.run()
def __init__(self):
vispy.scene.SceneCanvas.__init__(self,
keys='interactive',
size=(800, 800),
show=True)
# Create several visuals demonstrating different features of Line
self.lines = [
# agg-mode lines:
visuals.Line(pos=pos, color=color, mode='agg'), # per-vertex color
visuals.Line(pos=pos, color=(0, 0.5, 0.3, 1), mode='agg'), # solid
visuals.Line(pos=pos, color=color, width=5, mode='agg'), # wide
# GL-mode lines:
visuals.Line(pos=pos, color=color, mode='gl'),
visuals.Line(pos=pos, color=(0, 0.5, 0.3, 1), mode='gl'),
visuals.Line(pos=pos, color=color, width=5, mode='gl'),
# GL-mode: "connect" not available in AGG mode yet
visuals.Line(pos=pos,
color=(0, 0.5, 0.3, 1),
connect='segments',
mode='gl'), # only connect alternate vert pairs
visuals.Line(pos=pos,
color=(0, 0.5, 0.3, 1),
connect=connect,
mode='gl'), # connect specific pairs
]
counts = [0, 0]
for i, line in enumerate(self.lines):
# arrange lines in a grid
tidx = (line.mode == 'agg')
x = 400 * tidx
y = 140 * (counts[tidx] + 1)
counts[tidx] += 1
line.transform = STTransform(translate=[x, y])
# redraw the canvas if any visuals request an update
line.events.update.connect(lambda evt: self.update())
line.parent = self.central_widget
self.texts = [
visuals.Text('GL',
bold=True,
font_size=24,
color='w',
pos=(200, 40),
parent=self.central_widget),
visuals.Text('Agg',
bold=True,
font_size=24,
color='w',
pos=(600, 40),
parent=self.central_widget)
]
def draw_3D(*datas, labels=None):
canvas = vispy.scene.SceneCanvas(keys='interactive',
show=True,
bgcolor="white")
view = canvas.central_widget.add_view()
pos, colors = [], []
D = len(datas)
cm = matplotlib.cm.rainbow(np.linspace(0, 1, D))
for i, data in enumerate(datas):
pos.extend(data.T)
color = cm[i]
colors.extend([color] * len(data.T))
colors = np.array(colors)
pos = np.array(pos)
# create scatter object and fill in the data
scatter = visuals.Markers()
scatter.set_data(pos, edge_color=None, face_color=colors, size=5)
view.add(scatter)
view.camera = 'turntable' # or try 'arcball'
# add a colored 3D axis for orientation
axis = visuals.XYZAxis(parent=view.scene)
view.add(axis)
if labels is not None: # legend
for i, label in enumerate(labels):
leg = visuals.Text(label, color=cm[i], pos=(0, 10 * i))
canvas.scene.add(leg)
return canvas
def plot_events(self):
n_events = len(self.evlog)
event_points = np.zeros((n_events, 3))
event_texts = []
i = 0
for name, value in self.evlog.items():
if not 't' in value:
continue
t = value['t']
r = self.r(t)
event_points[i] = r
event_texts.append(name)
i += 1
self.trajec_event_markers.set_data(event_points,
face_color='white',
edge_color='yellow',
size=10.0)
text_points = event_points + np.array([0.5, 0, 0])
# if self.trajec_event_texts is not None:
# self.trajec_event_texts =
self.trajec_event_texts = visuals.Text(event_texts,
color='yellow',
font_size=128,
pos=text_points)
self.view.add(self.trajec_event_texts)
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 attach_cameras_to_view(reconstruction,
view,
data_path,
length=1,
font_size=12):
nW = reconstruction.cameras.values()[0].width
nH = reconstruction.cameras.values()[0].height
fx = 2000.0
fy = 2000.0
u0 = nW / 2
v0 = nH / 2
ordered_shots = collections.OrderedDict(
sorted(reconstruction.shots.items()))
num_shots = len(ordered_shots)
## record all camera nodes
camera_nodes = {}
text_nodes = {}
for shot in range(num_shots):
rot = ordered_shots.values()[shot].pose.rotation
trans = ordered_shots.values()[shot].pose.translation
# img = mpimg.imread(data_path+'/images/'+ordered_shots.values()[shot].id)
img = mpimg.imread(data_path[ordered_shots.values()[shot].id])
if (img.dtype.type is np.uint8 or img.dtype.type is np.uint16):
img = img.astype(np.float32) / 255.0
camera_nodes[shot] = CameraNode(fx,
fy,
u0,
v0,
length=length,
nW=nW,
nH=nH,
rot=rot,
trans=trans,
image=img,
parent=view.scene)
### show text
origin = ordered_shots.values()[shot].pose.get_origin()
text_nodes[shot] = visuals.Text(ordered_shots.values()[shot].id,
color='red',
bold=True,
parent=view.scene,
pos=origin,
font_size=font_size)
return camera_nodes, text_nodes
def text_plot(self):
"""Plot some text for each source.
The text is then translate to not cover the source. If no text is
detected, a empty text object is created.
"""
if self.stext is not None:
# Create text object :
self.stextmesh = visu.Text(text=self.stext, color=self.stextcolor,
font_size=self.stextsize, pos=self.xyz,
bold=True, name='SourcesText')
# Set text texture :
self.stextmesh.set_gl_state('translucent', depth_test=True)
# Apply a transformation to text elements to not cover sources :
self.stextmesh.transform = vist.STTransform(
translate=self.stextshift)
else:
self.stextmesh = visu.Text(name='NoneText')
def test_colorbar_label_as_textvisual():
with TestingCanvas() as c:
label = visuals.Text("my label")
colorbar = create_colorbar(pos=(50, 50),
size=(60, 4),
orientation='top',
label=label)
colorbar.cmap = "ice"
assert colorbar.label.text == "my label"
assert colorbar.label is label
c.draw_visual(colorbar)
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 __init__(self):
scene.SceneCanvas.__init__(
self,
keys='interactive', size=(512, 512),
title="Marker demo [press space to change marker]",
bgcolor='white'
)
self.index = 0
self.markers = visuals.Markers()
self.markers.set_data(pos, face_color=green, scaling=True)
self.markers.set_symbol(impl_visuals.marker_types[self.index])
self.text = visuals.Text(impl_visuals.marker_types[self.index],
pos=(80, 15), font_size=14,
color='black', parent=self.scene)
def __init__(self, s_xyz=None, s_data=None, s_color='#ab4652',
s_opacity=1.0, s_radiusmin=5.0, s_radiusmax=10.0,
s_edgecolor=None, s_edgewidth=0.6, s_scaling=False,
s_text=None, s_symbol='disc', s_textcolor='white',
s_textsize=3, s_textshift=(0, 2, 0), s_mask=None,
s_maskcolor='gray', s_cmap='inferno', s_clim=(0., 1.),
s_vmin=None, s_vmax=None, s_under=None, s_over=None,
s_projecton='surface', s_system='mni', **kwargs):
"""Init."""
# Initialize elements :
self.xyz = s_xyz
self.data = s_data
self.color = s_color
self.edgecolor = color2vb(s_edgecolor)
self.edgewidth = s_edgewidth
self.alpha = s_opacity
self.scaling = s_scaling
self.radiusmin = s_radiusmin
self.radiusmax = s_radiusmax
self.symbol = s_symbol
self.stext = s_text
self.stextcolor = color2vb(s_textcolor)
self.stextsize = s_textsize
self.stextshift = s_textshift
self.smask = s_mask
self.smaskcolor = color2vb(s_maskcolor)
self.projecton = s_projecton
self.system = s_system
self._defcolor = 'slateblue'
self._rescale = 3.0
# Plot :
if self.xyz is not None:
self.prepare2plot()
self.plot()
self.text_plot()
else:
self.mesh = visu.Markers(name='NoneSources')
self.stextmesh = visu.Text(name='NoneText')
# Vmin/Vmax only active if not None and in [clim[0], clim[1]] :
isvmin = (s_vmin is not None) and (
s_clim[0] < s_vmin < s_clim[1])
isvmax = (s_vmax is not None) and (
s_clim[0] < s_vmax < s_clim[1])
# Initialize colorbar elements :
CbarArgs.__init__(self, s_cmap, s_clim, isvmin, s_vmin,
isvmax, s_vmax, s_under, s_over)
def __init__(self):
scene.SceneCanvas.__init__(
self,
keys='interactive', size=(512, 512),
title="Marker demo [press space to change marker]",
bgcolor='white'
)
self.unfreeze()
self.index = 0
self.markers = visuals.Markers()
self.markers.set_data(pos, face_color=(0, 1, 0), scaling=False)
self.markers.symbol = self.markers.symbols[self.index]
self.text = visuals.Text(self.markers.symbols[self.index],
pos=(80, 15), font_size=14,
color='black', parent=self.scene)
self.freeze()
def _update_radius(self, timepoint=None):
"""Update marker's radius."""
logger.debug("Weird edge arround markers (source_obj.py)")
if not hasattr(self, 'radius'):
if np.unique(self._data).size == 1:
self.radius = self._radius_min * np.ones((len(self, )))
else:
self.radius = normalize(self._data.copy(),
tomin=self._radius_min,
tomax=self._radius_max)
if timepoint:
self._sources._data['a_size'] = self.radius[:, int(
timepoint)] # fs/time
if not hasattr(self, '_timer'):
self._timer = visuals.Text(str(int(timepoint)),
pos=[0, 100, 0],
bold=True,
name='Text',
color=color2vb('white'),
font_size=50,
parent=None) #self._node)
self._timer.text = str(int(timepoint))
self._timer.update()
else:
if len(self.radius.shape) == 2:
self._sources._data['a_size'] = np.mean(self.radius, axis=1)
else:
self._sources._data['a_size'] = self.radius
to_hide = self.hide
# Marker size + egde width = 0 and text='' for hidden sources :
self._sources._data['a_size'][to_hide] = 0.
self._sources._data['a_edgewidth'][to_hide] = 0.
if isinstance(self._mask_radius, (int, float)):
self._sources._data['a_size'][self._mask] = self._mask_radius
text = np.array(self._text.copy())
text[to_hide] = ''
self._sources_text.text = text
self.update()
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 scatter(pos,
mfc=[0.5, 0.5, 0.5, 0.8],
mec=None,
mfs=8,
mes=1,
bgc=[0.9, 0.9, 0.9],
scaling=False,
symbol='disc'):
""" Display a scatter plot in 2D or 3D.
Parameters
----------
pos : array
The array of locations to display each symbol.
mfc : Color | ColorArray
The color used to draw each symbol interior.
mec : Color | ColorArray
The color used to draw each symbol outline.
mfs : float or array
The symbol size in px.
mes : float | None
The width of the symbol outline in pixels.
bgc : Color
The color used for the background.
scaling : bool
If set to True, marker scales when rezooming.
symbol : str
The style of symbol to draw ('disc', 'arrow', 'ring', 'clobber',
'square', 'diamond', 'vbar', 'hbar', 'cross', 'tailed_arrow', 'x',
'triangle_up', 'triangle_down', 'star').
"""
# Create the Canvas, the Scene and the View
canvas = scene.SceneCanvas(keys='interactive', show=True, bgcolor=bgc)
view = canvas.central_widget.add_view()
# Create the scatter plot
scatter = visuals.Markers()
scatter.set_data(pos,
face_color=mfc,
edge_color=mec,
scaling=scaling,
size=mfs,
edge_width=mes,
symbol=symbol)
view.add(scatter)
# 2D Shape
if pos.shape[1] == 2:
# Set the camera properties
view.camera = scene.PanZoomCamera(aspect=1)
view.camera.set_range()
# Create lines to know the position of the cursor
tr = canvas.scene.node_transform(scatter)
win_xmin, win_ymax = tr.map([0, 0])[:2]
win_xmax, win_ymin = tr.map(canvas.size)[:2]
win_xsize, win_ysize = win_xmax - win_xmin, win_ymax - win_ymin
prop = .015
tick_size = prop * win_xsize
top_line = scene.visuals.Line(pos=np.array(
[[win_xmin, win_ymax], [win_xmin, win_ymax - tick_size]]),
color=[.2, .2, .2, 0.5],
width=1,
parent=view.scene,
method='gl')
right_line = scene.visuals.Line(pos=np.array(
[[win_xmax, win_ymin], [win_xmax - tick_size, win_ymin]]),
color=[.2, .2, .2, 0.5],
width=1,
parent=view.scene,
method='gl')
bottom_line = scene.visuals.Line(pos=np.array(
[[win_xmax, win_ymin], [win_xmax, win_ymin + tick_size]]),
color=[.2, .2, .2, 0.5],
width=1,
parent=view.scene,
method='gl')
left_line = scene.visuals.Line(pos=np.array(
[[win_xmin, win_ymax], [win_xmin + tick_size, win_ymax]]),
color=[.2, .2, .2, 0.5],
width=1,
parent=view.scene,
method='gl')
cross_hline = scene.visuals.Line(pos=np.array(
[[win_xmax, win_ymin], [win_xmax, win_ymin + tick_size]]),
color=[0, 0, 0, 1],
width=2,
parent=view.scene,
method='gl')
cross_vline = scene.visuals.Line(pos=np.array(
[[win_xmin, win_ymax], [win_xmin + tick_size, win_ymax]]),
color=[0, 0, 0, 1],
width=2,
parent=view.scene,
method='gl')
# TODO: create rectangle around the text
# Create text to give cursor position
text_xline = visuals.Text('',
bold=False,
font_size=12,
color=[0, 0, 0, 1],
pos=[50, 50],
anchor_x='left',
anchor_y='baseline')
text_yline = visuals.Text('',
bold=False,
font_size=12,
color=[0, 0, 0, 1],
pos=[50, 50],
anchor_x='left',
anchor_y='baseline')
view.add(text_xline)
view.add(text_yline)
# When the mouse move, refresh the cursor position
@canvas.events.mouse_move.connect
def on_mouse_move(event):
# Find the cursor position in the windows coordinate
tr = canvas.scene.node_transform(scatter)
x, y = tr.map(event.pos)[:2]
# Find the min and max for both axis in the windows coordinate
win_xmin, win_ymax = tr.map([0, 0])[:2]
win_xmax, win_ymin = tr.map(canvas.size)[:2]
win_xsize, win_ysize = win_xmax - win_xmin, win_ymax - win_ymin
tick_size = prop * win_xsize
#refresh
xtext, ytext = str('%.2e' % x), str('%.2e' % y)
text_xline.text = xtext
text_xline.pos = [x, win_ymin]
text_yline.text = ytext
text_yline.pos = [win_xmin, y]
top_line.set_data(
pos=np.array([[x, win_ymax], [x, win_ymax - tick_size]]))
right_line.set_data(
pos=np.array([[win_xmax, y], [win_xmax - tick_size, y]]))
bottom_line.set_data(
pos=np.array([[x, win_ymin], [x, win_ymin + tick_size]]))
left_line.set_data(
pos=np.array([[win_xmin, y], [win_xmin + tick_size, y]]))
cross_hline.set_data(
pos=np.array([[x - tick_size / 2, y], [x + tick_size / 2, y]]))
cross_vline.set_data(
pos=np.array([[x, y - tick_size / 2], [x, y + tick_size / 2]]))
# 3D Shape
elif pos.shape[1] == 3:
view.camera = 'turntable'
app.run()
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 __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')
# xmin, xmax = "%.4g" % np.nanmin(vol1[])
scatter = scene.visuals.Markers()
scatter.set_data(pos, face_color=(0, 1, 0), scaling=False)
index = 1
# scatter.symbol = 'star'
scatter.symbol = impl_visuals.marker_types[index]
scatter.transform = scene.STTransform(translate=(s[2] / 2.0, s[1] / 2.0, 0))
view.add(scatter)
# Add text visual here
text = visuals.Text(impl_visuals.marker_types[index],
pos=(80, 15),
font_size=14,
color='white',
parent=canvas.scene)
canvas.freeze()
# canvas.update()
# create colormaps that work well for translucent and additive volume rendering
class TransFire(BaseColormap):
glsl_map = """
vec4 translucent_fire(float t) {
return vec4(pow(t, 0.5), t, t*t, max(0, t*1.05 - 0.05));
}
"""
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
pos += centers[indexes]
scatter = visuals.Markers()
scatter.set_data(pos, edge_color=None, face_color=(1, 1, 1, 0.3), size=5)
vb3.add(scatter)
grid2 = visuals.GridLines(parent=vb3.scene)
vb3.camera = MagnifyCamera(mag=3, size_factor=0.3, radius_ratio=0.9)
vb3.camera.rect = (-5, -5, 10, 10)
# Add helpful text
text1 = visuals.Text("mouse wheel = magnify",
pos=(100, 15),
font_size=14,
color='white',
parent=canvas.scene)
text2 = visuals.Text("right button = zoom",
pos=(100, 30),
font_size=14,
color='white',
parent=canvas.scene)
if __name__ == '__main__':
import sys
if sys.flags.interactive != 1:
vispy.app.run()
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 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
def __init__(self, name, xyz, data=None, color='red', alpha=1.,
symbol='disc', radius_min=5., radius_max=10., edge_width=0.,
edge_color='black', system='mni', mask=None,
mask_color='gray', text=None, text_size=3.,
text_color='black', text_bold=False,
text_translate=(0., 2., 0.), visible=True, transform=None,
parent=None, verbose=None, _z=-10., **kw):
"""Init."""
VisbrainObject.__init__(self, name, parent, transform, verbose, **kw)
# _______________________ CHECKING _______________________
# XYZ :
sh = xyz.shape
assert sh[1] in [2, 3]
self._n_sources = sh[0]
pos = xyz if sh[1] == 3 else np.c_[xyz, np.full((len(self),), _z)]
# Radius min and max :
assert all([isinstance(k, (int, float)) for k in (
radius_min, radius_max)])
radius_max = max(radius_min, radius_max)
self._radius_min, self._radius_max = radius_min, radius_max
# Data :
if data is None:
data = np.ones((len(self),))
else:
data = np.asarray(data).ravel()
assert len(data) == len(self)
self._data = vispy_array(data)
# System :
pos = pos if system == 'mni' else tal2mni(pos)
self._xyz = vispy_array(pos)
# Color :
self._color = color
# Edges :
self._edge_color, self._edge_width = edge_color, edge_width
# Mask :
if mask is None:
mask = [False] * len(self)
self._mask = np.asarray(mask).ravel().astype(bool)
assert len(self._mask) == len(self)
self._mask_color = color2vb(mask_color)
# Text :
self._text_size = text_size
self._text_color = text_color
self._text_translate = text_translate
# _______________________ MARKERS _______________________
self._sources = visuals.Markers(pos=self._xyz, name='Markers',
edge_color=edge_color,
edge_width=edge_width,
symbol=symbol, parent=self._node)
# _______________________ TEXT _______________________
tvisible = text is None
self._text = [''] * len(self) if tvisible else text
self._text = np.array(self._text)
assert len(self._text) == len(self)
self._sources_text = visuals.Text(self._text, pos=self._xyz,
bold=text_bold, name='Text',
color=color2vb(text_color),
font_size=text_size,
parent=self._node)
self._sources_text.visible = not tvisible
tr = vist.STTransform(translate=text_translate)
self._sources_text.transform = tr
# _______________________ UPDATE _______________________
# Radius / color :
self.visible = visible
self._update_radius()
self._update_color()
self.alpha = alpha
def put_text(view, pos, text, font_size=18):
print text
t = visuals.Text(text, parent=view, color='white')
t.font_size = font_size
t.pos = pos