def __init__(self):
app.Canvas.__init__(self, keys='interactive')
n = 10000
pos = 0.25 * np.random.randn(n, 2).astype(np.float32)
color = np.random.uniform(0, 1, (n, 3)).astype(np.float32)
size = np.random.uniform(2, 12, (n, 1)).astype(np.float32)
self.points = MarkerVisual(pos=pos, color=color, size=size)
self.panzoom = STTransform(scale=(1, 0.2), translate=(0, 500))
w2 = (self.size[0]/2, self.size[1]/2)
self.transform = ChainTransform([self.panzoom,
STTransform(scale=w2, translate=w2),
LogTransform(base=(0, 2, 0))])
self.tr_sys = TransformSystem(self)
self.tr_sys.visual_to_document = self.transform
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 800))
# Create several visuals demonstrating different features of Line
self.lines = [
# agg-method lines:
# per-vertex color
visuals.LineVisual(pos=pos, color=color, method='agg'),
# solid
visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), method='agg'),
# wide
visuals.LineVisual(pos=pos, color=color, width=5, method='agg'),
# GL-method lines:
visuals.LineVisual(pos=pos, color=color, method='gl'),
visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), method='gl'),
visuals.LineVisual(pos=pos, color=color, width=5, method='gl'),
# GL-method: "connect" not available in AGG method yet
# only connect alternate vert pairs
visuals.LineVisual(pos=pos,
color=(0, 0.5, 0.3, 1),
connect='segments',
method='gl'),
# connect specific pairs
visuals.LineVisual(pos=pos,
color=(0, 0.5, 0.3, 1),
connect=connect,
method='gl'),
]
counts = [0, 0]
for i, line in enumerate(self.lines):
# arrange lines in a grid
tidx = (line.method == '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())
self.texts = [
visuals.TextVisual('GL',
bold=True,
font_size=24,
color='w',
pos=(200, 40)),
visuals.TextVisual('Agg',
bold=True,
font_size=24,
color='w',
pos=(600, 40))
]
for text in self.texts:
text.transform = NullTransform()
self.visuals = self.lines + self.texts
self.show()
def _master_transform(self):
"""vispy.visuals.transforms.STTransform:
Central node's firstmost transform.
"""
# whenever a new parent is set, the transform is reset
# to a NullTransform so we reset it here
if not isinstance(self.node.transform, STTransform):
self.node.transform = STTransform()
return self.node.transform
def put_observer(view, coords, radius, color='black', edge_color='blue'):
""" Put the observer on the scene
radius and coords in Mpc
"""
observer = visuals.Sphere(radius=radius,
method='latitude',
parent=view.scene,
color=color,
edge_color=edge_color)
observer.transform = STTransform(translate=coords)
def test_histogram():
"""Test histogram visual"""
size = (200, 100)
with TestingCanvas(size=size, bgcolor='w') as c:
np.random.seed(2397)
data = np.random.normal(size=100)
hist = Histogram(data, bins=20, color='k', parent=c.scene)
hist.transform = STTransform((size[0] // 10, -size[1] // 20, 1),
(100, size[1]))
assert_image_approved(c.render(), "visuals/histogram.png")
def __init__(self):
self.image = visuals.ImageVisual(image, method='subdivide')
self.image_transform = STTransform(scale=(7, 7), translate=(50, 50))
vispy.app.Canvas.__init__(self, keys='interactive')
self.size = (800, 800)
self.show()
# Create a TransformSystem that will tell the visual how to draw
self.tr_sys = TransformSystem(self)
self.tr_sys.visual_to_document = self.image_transform
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(512, 512),
title="Marker demo [press space to change marker]")
self.index = 0
self.markers = visuals.MarkersVisual()
self.markers.set_data(pos, face_color=colors)
self.markers.symbol = visuals.marker_types[self.index]
self.markers.transform = STTransform()
self.show()
def __init__(self):
vispy.app.Canvas.__init__(self, keys='interactive', size=(800, 800))
self.image = visuals.ImageVisual(get_image(), method='subdivide')
# scale and center image in canvas
s = 700. / max(self.image.size)
t = 0.5 * (700. - (self.image.size[0] * s)) + 50
self.image.transform = STTransform(scale=(s, s), translate=(t, 50))
self.show()
def test_canvas_render(blend_func):
"""Test rendering a canvas to an array.
Different blending functions are used to test what various Visuals may
produce without actually using different types of Visuals.
"""
with TestingCanvas(size=(125, 125), show=True, title='run') as c:
view = c.central_widget.add_view()
im1 = np.zeros((100, 100, 4)).astype(np.float32)
im1[:, :, 0] = 1
im1[:, :, 3] = 1
im2 = np.zeros((50, 50, 4)).astype(np.float32)
im2[:, :, 1] = 1
im2[:, :, 3] = 0.4
# Create the image
image1 = scene.visuals.Image(im1, parent=view.scene)
image1.transform = STTransform(translate=(20, 20, 0))
image2 = scene.visuals.Image(im2, parent=view.scene)
image2.transform = STTransform(translate=(0, 0, -1))
if blend_func:
image1.set_gl_state(preset='translucent', blend_func=blend_func)
image2.set_gl_state(preset='translucent', blend_func=blend_func)
rgba_result = c.render()
rgb_result = c.render(alpha=False)
# the results should be the same except for alpha
np.testing.assert_allclose(rgba_result[..., :3], rgb_result)
# the image should have something drawn in it
assert not np.allclose(rgba_result[..., :3], 0)
# the alpha should not be completely transparent
assert not np.allclose(rgba_result[..., 3], 0)
if blend_func is None or 'one' in blend_func:
# no transparency
np.testing.assert_allclose(rgba_result[..., 3], 255)
else:
# the alpha should have some transparency
assert (rgba_result[..., 3] != 255).any()
def test_histogram():
"""Test histogram visual"""
size = (200, 100)
with TestingCanvas(size=size, bgcolor='w') as c:
np.random.seed(2397)
data = np.random.normal(size=100)
hist = Histogram(data, bins=20, color='k')
hist.transform = STTransform((size[0] // 10, -size[1] // 20, 1),
(100, size[1]))
c.draw_visual(hist)
assert_image_approved("screenshot", "visuals/histogram.png")
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(512, 512),
title="Marker demo [press space to change marker]")
self.index = 0
self.scale = 1.
self.tr_sys = TransformSystem(self)
self.tr_sys.visual_to_document = STTransform()
self.markers = visuals.MarkersVisual()
self.markers.set_data(pos, face_color=colors)
self.markers.set_symbol(visuals.marker_types[self.index])
self.show()
def attach(self, viewer, view, canvas, parent=None, order=0):
super().attach(viewer, view, canvas, parent, order)
self.node = Markers(pos=self._markers_data, parent=parent)
self.node.transform = STTransform()
self.node.order = order
self._nodes = [self.node]
self._viewer.dims.events.ndisplay.connect(self._on_data_change)
self._on_data_change(None)
def test_histogram():
"""Test histogram visual"""
size = (200, 100)
with TestingCanvas(size=size, bgcolor='w') as c:
data = np.array([0., 0., 1.])
hist = Histogram(data, bins=2, color='k')
# the result should be 2 high by 1 wide, so we scale it up
hist.transform = STTransform((size[0], -size[1] // 2, 1), (0, size[1]))
c.draw_visual(hist)
expected = np.zeros(size[::-1] + (3, ))
expected[:size[1] // 2, -size[0] // 2:] = 1.
assert_image_equal("screenshot", expected)
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)
def __init__(self, scale_bar, camera, parent=None, order=0):
self._scale_bar = scale_bar
self._camera = camera
self._data = np.array([
[0, 0, -1],
[1, 0, -1],
[0, -5, -1],
[0, 5, -1],
[1, -5, -1],
[1, 5, -1],
])
self._default_color = np.array([1, 0, 1, 1])
self._target_length = 100
self._scale = 1
self.node = Line(connect='segments',
method='gl',
parent=parent,
width=3)
self.node.order = order
self.node.transform = STTransform()
self.text_node = Text(pos=[0, 0], parent=parent)
self.text_node.order = order
self.text_node.transform = STTransform()
self.text_node.font_size = 10
self.text_node.anchors = ('center', 'center')
self.text_node.text = f'{1}'
self._scale_bar.events.visible.connect(self._on_visible_change)
self._scale_bar.events.colored.connect(self._on_data_change)
self._scale_bar.events.background_color.connect(self._on_data_change)
self._scale_bar.events.ticks.connect(self._on_data_change)
self._scale_bar.events.position.connect(self._on_position_change)
self._camera.events.zoom.connect(self._on_zoom_change)
self._on_visible_change(None)
self._on_data_change(None)
self._on_position_change(None)
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
ps = self.pixel_scale
n = 10000
pos = 0.25 * np.random.randn(n, 2).astype(np.float32)
color = np.random.uniform(0, 1, (n, 3)).astype(np.float32)
size = np.random.uniform(2*ps, 12*ps, (n, 1)).astype(np.float32)
self.points = MarkerVisual(pos=pos, color=color, size=size)
self.panzoom = STTransform(scale=(1, 0.2), translate=(0, 500))
w2 = (self.size[0]/2, self.size[1]/2)
self.transform = ChainTransform([self.panzoom,
STTransform(scale=w2, translate=w2),
LogTransform(base=(0, 2, 0))])
self.tr_sys = TransformSystem(self)
self.tr_sys.visual_to_document = self.transform
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
ps = self.pixel_scale
n = 10000
pos = 0.25 * np.random.randn(n, 2).astype(np.float32)
color = np.random.uniform(0, 1, (n, 3)).astype(np.float32)
size = np.random.uniform(2*ps, 12*ps, (n, 1)).astype(np.float32)
self.points = MarkerVisual(pos=pos, color=color, size=size)
w, h = self.size
self.points.transform = STTransform(scale=(w / 2., h / 2.),
translate=(w / 2., h / 2.))
def __init__(self):
# Define several Line visuals that use the same position data
self.lines = [visuals.LineVisual(pos=pos)
for i in range(6)]
self.lines[0].transform = STTransform(translate=(0, 50))
# Clipping filter (requires update when window is resized)
self.lines[1].transform = STTransform(translate=(400, 50))
self.clipper = Clipper([500, 725, 200, 50])
self.lines[1].attach(self.clipper)
# Opacity filter
self.lines[2].transform = STTransform(translate=(0, 150))
self.lines[2].attach(Alpha(0.4))
# Color filter (for anaglyph stereo)
self.lines[3].transform = STTransform(translate=(400, 150))
self.lines[3].attach(ColorFilter([1, 0, 0, 1]))
# A custom filter
class Hatching(object):
def __init__(self):
self.shader = Function("""
void screen_filter() {
float f = gl_FragCoord.x * 0.4 + gl_FragCoord.y;
f = mod(f, 20);
if( f < 5.0 ) {
discard;
}
if( f < 20.0 ) {
gl_FragColor.g = gl_FragColor.g + 0.05 * (20-f);
}
}
""")
def _attach(self, visual):
visual._get_hook('frag', 'post').add(self.shader())
self.lines[4].transform = STTransform(translate=(0, 250))
self.lines[4].attach(Hatching())
# Mixing filters
self.lines[5].transform = STTransform(translate=(400, 250))
self.lines[5].attach(ColorFilter([1, 0, 0, 1]))
self.lines[5].attach(Hatching())
app.Canvas.__init__(self, keys='interactive', size=(800, 800))
for line in self.lines:
tr_sys = visuals.transforms.TransformSystem(self)
tr_sys.visual_to_document = line.transform
line.tr_sys = tr_sys
self.show(True)
def draw_init(self, backgroundImg=False, fontsize=14, fontColor="white"):
gloo.clear(color="#231e1f")
# gloo.set_state("translucent", depth_test=False,blend=True)
try:
self.text.clear()
except:
pass
self.selected_point = -1
self.fontsize = fontsize
panzoom = PanZoomTransform(self.canvas)
if backgroundImg:
self.im = read_png("timg.png")
self.image = ImageVisual(self.im, method="subdivide")
self.image.update = self.canvas.update
self.image.transform = STTransform(
scale=(2 / self.image.size[0], 2 / self.image.size[1]),
translate=(-1, -1),
)
else:
self.image = None
self.markers = PointCollection(
"agg",
vertex=self.pvertex,
fragment=self.pfragment,
color="shared",
size="local",
transform=panzoom,
)
self.lines = PathCollection(
mode="agg",
vertex=self.lvertex,
fragment=self.lfragment,
color="shared",
linewidth="global",
transform=panzoom,
)
self.markers.update.connect(self.canvas.update)
self.lines.update.connect(self.canvas.update)
self.text = TextVisual(u"", color="white")
self.text.font_size = self.fontsize
self.text.visible = False
self.textpos = None
self.canvas.events.draw.connect(self.on_draw)
self.canvas.events.resize.connect(self.on_resize)
self.canvas.events.mouse_press.connect(self.on_mouse_press)
self.canvas.show()
def load_animal(self):
self.marker = Animal(parent=self.view.scene, radius=200, color=(1,0,1,0.8))
self.marker.transform = STTransform()
self.marker.origin = self.origin
self.arrow = scene.visuals.Arrow(parent=self.view.scene, width=1.2, color=(0,1,0,1))
hd = np.array([[0,0],[100,100]])
self.arrow.set_data(pos=hd, arrows=hd.reshape((len(hd)//2, 4)))
@self.marker.connect
def on_move(target_pos):
if hasattr(self, 'jov'):
self.jov.teleport(prefix='console', target_pos=target_pos)
else:
self.current_pos = self._to_jovian_coord(target_pos).astype(np.float32)
def __init__(self):
# Define several Line visuals that use the same position data
# but have different colors and transformations
colors = [color, (1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1), (1, 1, 1, 1)]
self.lines = [visuals.LineVisual(pos=pos, color=colors[i])
for i in range(6)]
center = STTransform(translate=(400, 400))
self.lines[0].transform = center
self.lines[1].transform = (center *
STTransform(scale=(1, 0.1, 1)))
self.lines[2].transform = (center *
STTransform(translate=(200, 200, 0)) *
STTransform(scale=(0.3, 0.5, 1)))
self.lines[3].transform = (center *
STTransform(translate=(-200, -200, 0),
scale=(200, 1)) *
LogTransform(base=(10, 0, 0)) *
STTransform(translate=(1, 0, 0)))
self.lines[4].transform = AffineTransform()
self.lines[4].transform.rotate(45, (0, 0, 1))
self.lines[4].transform.scale((0.3, 0.3, 1))
self.lines[4].transform.translate((200, 200, 0))
self.lines[5].transform = (STTransform(translate=(200, 600, 0),
scale=(5, 5)) *
PolarTransform() *
LogTransform(base=(2, 0, 0)) *
STTransform(scale=(0.01, 0.1),
translate=(4, 20)))
app.Canvas.__init__(self, keys='interactive')
self.size = (800, 800)
self.show()
for line in self.lines:
tr_sys = visuals.transforms.TransformSystem(self)
tr_sys.visual_to_document = line.transform
line.tr_sys = tr_sys
def __init__(self):
app.Canvas.__init__(self,
title='Bezier lines example',
keys='interactive',
size=(400, 750))
self.lines = [
visuals.LineVisual(curves.curve4_bezier((10, 0), (50, -190),
(350, 190), (390, 0)),
color='w',
width=2,
method='agg'),
visuals.LineVisual(curves.curve4_bezier((10, 0), (190, -190),
(210, 190), (390, 0)),
color='w',
width=2,
method='agg'),
visuals.LineVisual(curves.curve3_bezier((10, 0), (30, 200),
(390, 0)),
color='w',
width=2,
method='agg')
]
# Translate each line visual downwards
for i, line in enumerate(self.lines):
x = 0
y = 200 * (i + 1)
line.transform = STTransform(translate=[x, y])
self.texts = [
visuals.TextVisual('Third order curve',
bold=True,
color='w',
font_size=14,
pos=(200, 75)),
visuals.TextVisual('Quadratic curve',
bold=True,
color='w',
font_size=14,
pos=(200, 525)),
]
for text in self.texts:
text.transform = NullTransform()
self.visuals = self.lines + self.texts
self.show()
def __init__(self):
app.Canvas.__init__(self, title="Simple NetworkX Graph",
keys="interactive", size=(600, 600))
graph = nx.adjacency_matrix(
nx.fast_gnp_random_graph(500, 0.005, directed=True))
layout = layouts.get_layout('force_directed', iterations=100)
self.visual = visuals.GraphVisual(
graph, layout=layout, line_color='black', arrow_type="stealth",
arrow_size=30, node_symbol="disc", node_size=20,
face_color=(1, 0, 0, 0.5), border_width=0.0, animate=True,
directed=False)
self.visual.transform = STTransform(self.visual_size, (20, 20))
self.show()
def add_observer(view,
coords=[118.34, 117.69, 119.2],
radius=1,
color='black',
edge_color='red'):
""" Put the observer on the scene
radius and coords in Mpc
"""
observer = visuals.Sphere(radius=radius,
method='latitude',
parent=view.scene,
color=color,
edge_color=edge_color)
observer.transform = STTransform(translate=coords)
return observer
def attach(self, viewer, view, canvas, parent=None, order=0):
super().attach(viewer, view, canvas, parent, order)
self._update_line_data()
self.node = Compound(
[Line(connect='segments', method='gl', width=4)],
parent=parent,
)
self.node.transform = STTransform()
self.node.order = order
self._nodes = [self.node]
self._viewer.camera.events.zoom.connect(self._on_zoom_change)
self._viewer.dims.events.ndisplay.connect(self._on_data_change)
self._on_data_change(None)
def __init__(self,
text=None,
color='black',
bold=False,
italic=False,
face='OpenSans',
font_size=12,
pos=[0, 0, 0],
rotation=0.,
anchor_x='center',
anchor_y='center',
method='cpu',
font_manager=None):
Visual.__init__(self,
vcode=self.VERTEX_SHADER,
fcode=self.FRAGMENT_SHADER)
# Check input
valid_keys = ('top', 'center', 'middle', 'baseline', 'bottom')
_check_valid('anchor_y', anchor_y, valid_keys)
valid_keys = ('left', 'center', 'right')
_check_valid('anchor_x', anchor_x, valid_keys)
# Init font handling stuff
# _font_manager is a temporary solution to use global mananger
self._font_manager = font_manager or FontManager(method=method)
self._face = face
self._bold = bold
self._italic = italic
self._update_font()
self._vertices = None
self._color_vbo = None
self._anchors = (anchor_x, anchor_y)
# Init text properties
self.color = color
self.text = text
self.font_size = font_size
self.pos = pos
self.rotation = rotation
self._text_scale = STTransform()
self._draw_mode = 'triangles'
self.set_gl_state(blend=True,
depth_test=False,
cull_face=False,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.freeze()
def __init__(self):
app.Canvas.__init__(self, size=(800, 600), keys="interactive")
img_data = get_mandlebrot_escape_values(600, 400)
self.image = ImageVisual(img_data, cmap=colormap)
image_transform = STTransform(scale=(1.3, 1.3), translate=(100, 0))
self.image_transform_sys = TransformSystem(self)
self.image_transform_sys.visual_to_document = image_transform
self.vertical_bar = get_vertical_bar()
# construct a default transform that does identity scaling
# and does not translate the coordinates
colorbar_transform = NullTransform()
self.colorbar_transform_sys = TransformSystem(self)
self.colorbar_transform_sys.visual_to_document = colorbar_transform
self.show()
def vprescale(obj, dist=1.):
"""Get the vispy transformation for rescaling objects.
Parameters
----------
obj : tuple
The ndarray of the object to rescale. Must be a (..., 2) or (..., 3).
dist : float | 1.
The final rescaling value.
Returns
-------
rescale : vispy.transformations
VisPy transformation to rescale.
"""
# Get minimum / maximum trough last dimension :
dim = tuple(np.arange(obj.ndim - 1, dtype=int))
ptp = np.max(obj, axis=dim) - np.min(obj, axis=dim)
return STTransform(scale=[dist / np.max(ptp)] * 3)
def open_multi():
# opening a 3D and 4D single-channel images in the same viewer
win = ImageWindow()
viewer = win.add_viewer()
h = 64
w = 64
d = 64
Z, Y, X = np.ogrid[-2.5:2.5:h * 1j, -2.5:2.5:w * 1j, -2.5:2.5:d * 1j]
image3D = np.empty((h, w, d), dtype=np.float32)
image3D[:] = np.exp(-X**2 - Y**2 -
Z**2) # * (1. + .5*(np.random.rand(h, w)-.5))
# image[-30:] = np.linspace(0, 1, w)
meta = dict(name='3D1C', itype='mono')
container = viewer.add_image(image3D, meta)
container.cmap = 'blues'
container.interpolation = 'spline36'
h = 64
w = 64
d = 64
b = 64
C, Z, Y, X = np.ogrid[-2.5:2.5:h * 1j, -2.5:2.5:w * 1j, -2.5:2.5:d * 1j,
-2.5:2.5:b * 1j]
image4D = np.empty((h, w, d, b), dtype=np.float32)
image4D[:] = np.exp(-X**2 - Y**2 - Z**2 -
C**2) # * (1. + .5*(np.random.rand(h, w)-.5))
# image[-30:] = np.linspace(0, 1, w)
meta = dict(name='4D1C', itype='mono')
container = viewer.add_image(image4D, meta)
container.cmap = 'blues'
container.interpolation = 'spline36'
scale = image3D.shape[0] / image4D.shape[0]
container.transform = STTransform(translate=[image3D.shape[0]],
scale=[scale] * 2)
viewer.view.camera.set_range()
win.show()
win.raise_()
return win
def draw_atoms_vispy(mol):
from vispy import scene
from vispy.visuals.transforms import STTransform
canvas = scene.SceneCanvas(keys='interactive',
bgcolor='black',
size=(800, 600),
show=True)
view = canvas.central_widget.add_view()
view.camera = 'arcball'
for at in mol.atoms:
atom_sphere = scene.visuals.Sphere(radius=SIZE_SCALE *
(vw_radius[at.name]),
method='ico',
parent=view.scene,
color=at_colours[at.name],
edge_color='black',
subdivisions=2)
atom_sphere.transform = STTransform(translate=at.xyz)
canvas.app.run()
