class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white')
self.tr_sys.auto_configure()
self.cube.draw(self.tr_sys)
def on_timer(self, event):
self.theta += .5
self.phi += .5
self.cube_transform.reset()
self.cube_transform.rotate(self.theta, (0, 0, 1))
self.cube_transform.rotate(self.phi, (0, 1, 0))
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.cube.transform = transforms.MatrixTransform()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.quaternion = Quaternion()
self.show()
def on_resize(self, event):
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
self.cube.transforms.configure(canvas=self, viewport=vp)
def on_draw(self, event):
self.context.clear('white')
self.cube.draw()
def on_mouse_move(self, event):
if event.button == 1 and event.last_event is not None:
x0, y0 = event.last_event.pos
x1, y1 = event.pos
w, h = self.size
self.quaternion = (self.quaternion *
Quaternion(*_arcball(x0, y0, w, h)) *
Quaternion(*_arcball(x1, y1, w, h)))
self.cube.transform.matrix = self.quaternion.get_matrix()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25),
color='red',
edge_color='black')
self.cube.transform = transforms.MatrixTransform()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.quaternion = Quaternion()
self.show()
def on_resize(self, event):
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
self.cube.transforms.configure(canvas=self, viewport=vp)
def on_draw(self, event):
self.context.clear('white')
self.cube.draw()
def on_mouse_move(self, event):
if event.button == 1 and event.last_event is not None:
x0, y0 = event.last_event.pos
x1, y1 = event.pos
w, h = self.size
self.quaternion = (self.quaternion *
Quaternion(*_arcball(x0, y0, w, h)) *
Quaternion(*_arcball(x1, y1, w, h)))
self.cube.transform.matrix = self.quaternion.get_matrix()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.quaternion = Quaternion()
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self.show()
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white')
self.tr_sys.auto_configure()
self.cube.draw(self.tr_sys)
def on_mouse_move(self, event):
if event.button == 1 and event.last_event is not None:
x0, y0 = event.last_event.pos
x1, y1 = event.pos
w, h = self.size
self.quaternion = (self.quaternion *
Quaternion(*_arcball(x0, y0, w, h)) *
Quaternion(*_arcball(x1, y1, w, h)))
self.cube_transform.matrix = self.quaternion.get_matrix()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.quaternion = Quaternion()
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self.show()
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white')
self.tr_sys.auto_configure()
self.cube.draw(self.tr_sys)
def on_mouse_move(self, event):
if event.button == 1 and event.last_event is not None:
x0, y0 = event.last_event.pos
x1, y1 = event.pos
w, h = self.size
self.quaternion = (self.quaternion *
Quaternion(*_arcball(x0, y0, w, h)) *
Quaternion(*_arcball(x1, y1, w, h)))
self.cube_transform.matrix = self.quaternion.get_matrix()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white')
self.tr_sys.auto_configure()
self.cube.draw(self.tr_sys)
def on_timer(self, event):
self.theta += .5
self.phi += .5
self.cube_transform.reset()
self.cube_transform.rotate(self.theta, (0, 0, 1))
self.cube_transform.rotate(self.phi, (0, 1, 0))
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25),
color='red',
edge_color='black')
self.cube.transform = transforms.MatrixTransform()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.quaternion = Quaternion()
self.show()
def __init__(self, connection, orientation):
self.con = connection
self.orientation = orientation
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((7.0, 4.0, 0.3),
color=Color(color='grey', alpha=0.1,
clip=False),
edge_color="black")
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('0.05', connect=self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red', edge_color="k")
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.quaternion = Quaternion()
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self.show()
def __init__(self):
self.cube = CubeVisual((1.0, 0.5, 0.25),
color='red',
edge_color='black')
self.theta = 0
self.phi = 0
app.Canvas.__init__(self,
'Cube',
keys='interactive',
show=True,
size=(400, 400))
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
class Canvas(app.Canvas):
def __init__(self, connection, orientation):
self.con = connection
self.orientation = orientation
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((7.0, 4.0, 0.3),
color=Color(color='grey', alpha=0.1,
clip=False),
edge_color="black")
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('0.05', connect=self.on_timer, start=True)
self.show()
def on_close(self, event):
self.con.close()
def on_resize(self, event):
# Set canvas viewport and reconfigure visual transforms to match.
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
self.cube.transforms.configure(canvas=self, viewport=vp)
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white', depth=True)
self.cube.draw()
def on_timer(self, event):
data = connection.get_data()
if data:
roll, pitch, yaw = orientation.data2roll_pitch_yaw(data)
# print("{}\t{}\t{}".format( *map(round,(roll,pitch,yaw))))
self.cube_transform.reset()
self.cube_transform.rotate(pitch, (1, 0, 0)) # Pitch
self.cube_transform.rotate(roll, (0, 1, 0)) # Roll
self.cube_transform.rotate(yaw, (0, 0, 1)) # Yaw
self.cube_transform.scale((20, 20, 0.001))
self.cube_transform.translate((200, 200))
self.update()
def __init__(self, *args, **kwargs):
self.cube = CubeVisual(size=(0.8, 0.5, 0.5),
color='red',
edge_color="k")
self.theta = 0
self.phi = 0
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = Timer('auto', connect=self.on_timer, start=True)
SceneCanvas.__init__(self, *args, **kwargs)
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.cube.transform = transforms.MatrixTransform()
self.cube.transform.scale((100, 100, 0.001))
self.cube.transform.translate((200, 200))
self.quaternion = Quaternion()
self.show()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color="k")
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def on_resize(self, event):
# Set canvas viewport and reconfigure visual transforms to match.
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
self.cube.transforms.configure(canvas=self, viewport=vp)
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white', depth=True)
self.cube.draw()
def on_timer(self, event):
self.theta += .5
self.phi += .5
self.cube_transform.reset()
self.cube_transform.rotate(self.theta, (0, 0, 1))
self.cube_transform.rotate(self.phi, (0, 1, 0))
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red', edge_color="k")
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def on_resize(self, event):
# Set canvas viewport and reconfigure visual transforms to match.
vp = (0, 0, self.physical_size[0], self.physical_size[1])
self.context.set_viewport(*vp)
self.cube.transforms.configure(canvas=self, viewport=vp)
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white', depth=True)
self.cube.draw()
def on_timer(self, event):
self.theta += .5
self.phi += .5
self.cube_transform.reset()
self.cube_transform.rotate(self.theta, (0, 0, 1))
self.cube_transform.rotate(self.phi, (0, 1, 0))
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.update()
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.quaternion = Quaternion()
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.cube_transform.scale((100, 100, 0.001))
self.cube_transform.translate((200, 200))
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self.show()
def __init__(self):
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color='black')
self.theta = 0
self.phi = 0
app.Canvas.__init__(self, 'Cube', keys='interactive', show=True,
size=(400, 400))
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.AffineTransform()
self.tr_sys = transforms.TransformSystem(self)
self.tr_sys.visual_to_document = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self):
app.Canvas.__init__(self, 'Cube', keys='interactive',
size=(400, 400))
self.cube = CubeVisual((1.0, 0.5, 0.25), color='red',
edge_color="k")
self.theta = 0
self.phi = 0
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
