def __init__(self,):
app.Canvas.__init__(self)
self.size = 800, 600
# fovy, zfar params
self.fovy = 45.0
self.zfar = 10.0
width, height = self.size
self.aspect = width / float(height)
self.program = gloo.Program(vert, frag)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.view = translate((0, 0, -5.0))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.visible = True
self._timer = app.Timer(1.0 / 60)
self._timer.connect(self.on_timer)
self._timer.start()
# ---------------------------------
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def __init__(self,):
app.Canvas.__init__(self)
self.size = 800, 600
# fovy, zfar params
self.fovy = 45.0
self.zfar = 10.0
width, height = self.size
self.aspect = width / float(height)
self.program = gloo.Program(vert, frag)
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5.0)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.visible = True
self._timer = app.Timer(1.0 / 60)
self._timer.connect(self.on_timer)
self._timer.start()
# ---------------------------------
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
self.size = 800, 600
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5)
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.transparency = 1
gloo.set_clear_color((0, 0, 0), 0.1)
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
#self._timer = app.Timer('auto', connect=self.on_timer, start=True) #Siempre poner un timer asi se pone bien la funcion update!! solo en pyglet, en pyqt5 funciona joya!!!
self._monitor = MidiMonitor(connect=self.on_midi)
self.show()
def __init__(self):
""" initialize the canvas """
app.Canvas.__init__(self,
size=(512, 512),
title='SR Voronoi Visualizer',
keys='interactive')
self.tri = 16 # 16 edges for each point
self.shrinkage = width / 2
# define vertices, indices, color
V, I, C = genVIC(pointz, self.tri, color)
self.BarStart = V.shape[0]
# set initial scale and center point
self.centerpos = [0, 0]
self.scale = 1
# hard-coded bar coordinates in the mean time
self.BarCenter = [0.9, -0.9]
self.BarDim = [
barWidth / pix2nm / self.shrinkage, 0.05 / np.sqrt(self.scale)
]
bV, bI, bC = genScaleBar(self.BarDim, self.BarCenter)
bI = bI + self.BarStart
# bind to data
V = np.vstack((V, bV))
I = np.vstack((I, bI))
C = np.vstack((C, bC))
# shader program
tet = gloo.Program(vert=vertex, frag=fragment) #, count=V.shape[0])
self.I = gloo.IndexBuffer(I)
self.V = gloo.VertexBuffer(V)
self.C = gloo.VertexBuffer(C)
tet['a_position'] = self.V
tet['a_color'] = self.C
# intialize transformation matrix
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
# set view
self.view = translate((0, 0, -3))
tet['u_model'] = self.model
tet['u_view'] = self.view
tet['u_projection'] = self.projection
# bind program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('black')
gloo.set_state('opaque')
gloo.set_polygon_offset(1.0, 1.0)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.timer.start()
# show the canvas
self.show()
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Monkey',
keys='interactive')
verts, faces, normals, texcoords = io.read_mesh(
"../model/monkey/monkey.obj")
obj = MeshData(verts, faces)
self.program = gloo.Program(vert=vertex, frag=fragment)
V = verts.astype('float32')
F = obj.get_faces().astype('uint32')
E = obj.get_edges().astype('uint32')
C = np.array([(1, 1, 1, 1)])
for i in range(len(V) - 1):
if i % 2 != 0:
C = np.append(C, [(1, 1, 1, 1)], axis=0)
else:
C = np.append(C, [(0, 0, 0, 1)], axis=0)
self.program['a_position'] = V
self.program['a_color'] = C.astype('float32')
self.F = gloo.IndexBuffer(F)
self.E = gloo.IndexBuffer(E)
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_polygon_offset(1.0, 1.0)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# set view
view = translate((0, 0, -5))
self.program['u_model'] = model
self.program['u_view'] = view
self.program['u_projection'] = projection
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.theta = 0.0
self.phi = 0.0
self.timer.start()
# show the canvas
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
rospy.init_node('imu_visualizer')
# assert_node_alive('torso_arduino')
rospy.Subscriber('imu/data_raw', Imu, self.on_imu)
# Cleanup when termniating the node
rospy.on_shutdown(self.shutdown)
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.yaw = 0 # yaw
self.roll = 0 # roll
self.pitch = 0 # pitch
gloo.set_clear_color('white')
# gloo.set_clear_color('black')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self.first = True
self.yaw0 = None
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
app.run()
rospy.signal_shutdown("Shutting done.")
self.shutdown()
print('Node shutdown.')
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
ones = np.ones((32, 32), dtype=np.float32)
zero = np.zeros((32, 32), dtype=np.float32)
cube_faces = np.stack([
np.dstack((zero, zero, ones)),
np.dstack((ones, zero, zero)),
np.dstack((zero, ones, zero)),
np.dstack((zero, ones, ones)),
np.dstack((ones, zero, ones)),
np.dstack((ones, ones, zero)),
],
axis=0)
self.program['u_cube'] = gloo.TextureCubeMap(cube_faces,
interpolation='linear',
wrapping='clamp_to_edge',
internalformat='rgb32f')
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def __init__(self, V, C, I, E, figsize=(512, 512), title='tetplot'):
""" initialize the canvas """
app.Canvas.__init__(self,
size=figsize,
title=title,
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(0.0, 0.0)
# update parameters
self.theta = 0.0
self.phi = 0.0
self.z = 5.0
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.timer.start()
# control plots
gloo.set_line_width(1.0)
# show the canvas
self.show()
def __init__(self, V, C, I, E,
figsize=(512, 512), title='tetplot'):
""" initialize the canvas """
app.Canvas.__init__(self, size=figsize, title=title,
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(0.0, 0.0)
# update parameters
self.theta = 0.0
self.phi = 0.0
self.z = 5.0
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.timer.start()
# control plots
gloo.set_line_width(1.0)
# show the canvas
self.show()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
dirname = path.join(path.abspath(path.curdir),'data')
positions, faces, normals, texcoords = \
read_mesh(load_data_file('cube.obj', directory=dirname))
self.filled_buf = gloo.IndexBuffer(faces)
if False:
self.program = gloo.Program(VERT_TEX_CODE, FRAG_TEX_CODE)
self.program['a_position'] = gloo.VertexBuffer(positions)
self.program['a_texcoord'] = gloo.VertexBuffer(texcoords)
self.program['u_texture'] = gloo.Texture2D(load_crate())
else:
self.program = gloo.Program(VERT_COLOR_CODE, FRAG_COLOR_CODE)
self.program['a_position'] = gloo.VertexBuffer(positions)
self.program['u_color'] = 1, 0, 0, 1
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('gray')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def __init__(self, ):
app.Canvas.__init__(self)
self.size = 800, 600
# fovy, zfar params
self.fovy = 45.0
self.zfar = 10.0
width, height = self.size
self.aspect = width / float(height)
n = 10000
self.data1 = np.zeros(n, [('a_position', np.float32, 3),
('a_normal', np.float32, 4),
('a_color', np.float32, 4)])
self.data1['a_position'] = 0.45 * np.random.randn(n, 3)
self.data1['a_normal'] = np.random.uniform(0.85, 1.00, (n, 4))
self.data1['a_color'] = 0, 0, 0, 1
self.program = gloo.Program(vert, frag)
#self.program.bind(gloo.VertexBuffer(self.data1))
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.view = translate((0, 0, -5.0))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.visible = True
self._timer = app.Timer(1.0 / 60)
self._timer.connect(self.on_timer)
self._timer.start()
# ---------------------------------
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def on_initialize(self, event):
gloo.set_clear_color((1, 1, 1, 1))
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def on_initialize(self, event):
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
def __init__(self):
""" initialize the canvas """
app.Canvas.__init__(self,
size=(512, 512),
title='scaling quad',
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# vertices
V = np.array([(0, 0, 0),
(1, 0, 0),
(1.0/2.0, np.sqrt(3.0)/2.0, 0),
(1.0/2.0, np.sqrt(3.0)/6.0, np.sqrt(2.0/3.0))],
dtype=np.float32)
# triangles specified by connecting matrix,
# it can also be initialized using itertools
I = np.array([(0, 1, 2),
(0, 3, 1),
(0, 2, 3),
(1, 3, 2)], dtype=np.uint32)
# edges, used for drawing outline
E = np.array([(0, 1), (1, 2), (2, 0), (1, 3), (2, 3), (0, 3)],
dtype=np.uint32)
# colors of vertices
C = np.array([(1, 0, 0, 1),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, 1, 0, 1)], dtype=np.float32)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# set view
view = translate((0, 0, -5))
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(1.0, 1.0)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.theta = 0.0
self.phi = 0.0
self.timer.start()
# show the canvas
self.show()
def __init__(self):
""" initialize the canvas """
app.Canvas.__init__(self,
size=(512, 512),
title='tetrahedron',
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# vertices
V = np.array([(0, 0, 0),
(1, 0, 0),
(1.0/2.0, np.sqrt(3.0)/2.0, 0),
(1.0/2.0, np.sqrt(3.0)/6.0, np.sqrt(2.0/3.0))],
dtype=np.float32)
# triangles specified by connecting matrix,
# it can also be initialized using itertools
I = np.array([(0, 1, 2),
(0, 3, 1),
(0, 2, 3),
(1, 3, 2)], dtype=np.uint32)
# edges, used for drawing outline
E = np.array([(0, 1), (1, 2), (2, 0), (1, 3), (2, 3), (0, 3)],
dtype=np.uint32)
# colors of vertices
C = np.array([(1, 0, 0, 1),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, 1, 0, 1)], dtype=np.float32)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# set view
view = translate((0, 0, -5))
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(1.0, 1.0)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.theta = 0.0
self.phi = 0.0
self.timer.start()
# show the canvas
self.show()
