def test_use_framebuffer():
"""Test drawing to a framebuffer"""
shape = (100, 300) # for some reason Windows wants a tall window...
data = np.random.rand(*shape).astype(np.float32)
use_shape = shape + (3, )
with Canvas(size=shape[::-1]) as c:
orig_tex = Texture2D(data)
fbo_tex = Texture2D(use_shape, format='rgb')
rbo = RenderBuffer(shape, 'color')
fbo = FrameBuffer(color=fbo_tex)
c._glir.set_verbose(True)
assert_equal(c.size, shape[::-1])
set_viewport((0, 0) + c.size)
with fbo:
draw_texture(orig_tex)
draw_texture(fbo_tex)
out_tex = _screenshot()[::-1, :, 0].astype(np.float32)
assert_equal(out_tex.shape, c.size[::-1])
assert_raises(TypeError, FrameBuffer.color_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.depth_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, fbo, 1.)
fbo.color_buffer = rbo
fbo.depth_buffer = RenderBuffer(shape)
fbo.stencil_buffer = None
print((fbo.color_buffer, fbo.depth_buffer, fbo.stencil_buffer))
clear(color='black')
with fbo:
clear(color='black')
draw_texture(orig_tex)
out_rbo = _screenshot()[:, :, 0].astype(np.float32)
assert_allclose(data * 255., out_tex, atol=1)
assert_allclose(data * 255., out_rbo, atol=1)
def on_initialize(self, event):
self.rho = 0.0
# Build cube data
# --------------------------------------
self.checker = Program(cube_vertex, cube_fragment)
self.checker['texture'] = checkerboard()
self.checker['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.checker['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
# sheet, indices = make_sheet((960, 1080))
# sheet_buffer = VertexBuffer(sheet)
left_eye = Texture2D((960, 1080, 3), interpolation='linear')
self.left_eye_buffer = FrameBuffer(left_eye, RenderBuffer((960, 1080)))
# Build program
# --------------------------------------
self.view = np.eye(4, dtype=np.float32)
self.program = Program(vertex, fragment)
distortion_buffer = VertexBuffer(make_distortion())
self.program.bind(distortion_buffer)
self.program['rotation'] = self.view
self.program['texture'] = left_eye
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self._set_projection(self.size)
def __init__(self):
app.Canvas.__init__(self, title='Grayscott Reaction-Diffusion',
size=(512, 512), keys='interactive')
self.scale = 4
self.comp_size = (256, 256)
comp_w, comp_h = self.comp_size
dt = 1.0
dd = 1.5
species = {
# name : [r_u, r_v, f, k]
'Bacteria 1': [0.16, 0.08, 0.035, 0.065],
'Bacteria 2': [0.14, 0.06, 0.035, 0.065],
'Coral': [0.16, 0.08, 0.060, 0.062],
'Fingerprint': [0.19, 0.05, 0.060, 0.062],
'Spirals': [0.10, 0.10, 0.018, 0.050],
'Spirals Dense': [0.12, 0.08, 0.020, 0.050],
'Spirals Fast': [0.10, 0.16, 0.020, 0.050],
'Unstable': [0.16, 0.08, 0.020, 0.055],
'Worms 1': [0.16, 0.08, 0.050, 0.065],
'Worms 2': [0.16, 0.08, 0.054, 0.063],
'Zebrafish': [0.16, 0.08, 0.035, 0.060]
}
P = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
P[:, :] = species['Unstable']
UV = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
UV[:, :, 0] = 1.0
r = 32
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 0] = 0.50
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 1] = 0.25
UV += np.random.uniform(0.0, 0.01, (comp_h, comp_w, 4))
UV[:, :, 2] = UV[:, :, 0]
UV[:, :, 3] = UV[:, :, 1]
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["params"] = P
self.compute["texture"] = UV
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dt'] = dt
self.compute['dx'] = 1.0 / comp_w
self.compute['dy'] = 1.0 / comp_h
self.compute['dd'] = dd
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
def test_renderbuffer():
# Set with no args
assert_raises(ValueError, RenderBuffer)
# Set shape only
R = RenderBuffer((10, 20))
assert R.shape == (10, 20)
assert R.format is None
# Set both shape and format
gloo.get_a_context().glir.clear()
R = RenderBuffer((10, 20), 'color')
assert R.shape == (10, 20)
assert R.format is 'color'
#
glir_cmds = R._context.glir.clear()
assert len(glir_cmds) == 2
assert glir_cmds[0][0] == 'CREATE'
assert glir_cmds[1][0] == 'SIZE'
# Orther formats
assert RenderBuffer((10, 20), 'depth').format == 'depth'
assert RenderBuffer((10, 20), 'stencil').format == 'stencil'
# Test reset size and format
R.resize((9, 9), 'depth')
assert R.shape == (9, 9)
assert R.format == 'depth'
R.resize((8, 8), 'stencil')
assert R.shape == (8, 8)
assert R.format == 'stencil'
# Wrong formats
assert_raises(ValueError, R.resize, (9, 9), 'no_format')
assert_raises(ValueError, R.resize, (9, 9), [])
# Resizable
R = RenderBuffer((10, 20), 'color', False)
assert_raises(RuntimeError, R.resize, (9, 9), 'color')
# Attaching sets the format
F = FrameBuffer()
#
R = RenderBuffer((9, 9))
F.color_buffer = R
assert F.color_buffer is R
assert R.format == 'color'
#
F.depth_buffer = RenderBuffer((9, 9))
assert F.depth_buffer.format == 'depth'
#
F.stencil_buffer = RenderBuffer((9, 9))
assert F.stencil_buffer.format == 'stencil'
def __init__(self):
app.Canvas.__init__(self,
title="Conway game of life",
size=(512, 512),
keys='interactive')
# Build programs
# --------------
self.comp_size = self.size
size = self.comp_size + (4, )
Z = np.zeros(size, dtype=np.float32)
Z[...] = np.random.randint(0, 2, size)
Z[:256, :256, :] = 0
gun = """
........................O...........
......................O.O...........
............OO......OO............OO
...........O...O....OO............OO
OO........O.....O...OO..............
OO........O...O.OO....O.O...........
..........O.....O.......O...........
...........O...O....................
............OO......................"""
x, y = 0, 0
for i in range(len(gun)):
if gun[i] == '\n':
y += 1
x = 0
elif gun[i] == 'O':
Z[y, x] = 1
x += 1
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["texture"] = Z
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dx'] = 1.0 / size[1]
self.compute['dy'] = 1.0 / size[0]
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def test_use_framebuffer():
"""Test drawing to a framebuffer"""
shape = (100, 300) # for some reason Windows wants a tall window...
data = np.random.rand(*shape).astype(np.float32)
use_shape = shape + (3, )
with Canvas(size=shape[::-1]) as c:
c.app.process_events()
c.set_current()
if c.app.backend_name.lower() == 'pyqt5':
# PyQt5 on OSX for some reason sets this to 1024x768...
c.size = shape[::-1]
c.app.process_events()
orig_tex = Texture2D(data)
fbo_tex = Texture2D(use_shape, format='rgb')
rbo = RenderBuffer(shape, 'color')
fbo = FrameBuffer(color=fbo_tex)
c.context.glir.set_verbose(True)
assert c.size == shape[::-1]
c.set_current()
set_viewport((0, 0) + c.size)
with fbo:
draw_texture(orig_tex)
draw_texture(fbo_tex)
out_tex = _screenshot()[::-1, :, 0].astype(np.float32)
assert out_tex.shape == c.size[::-1]
assert_raises(TypeError, FrameBuffer.color_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.depth_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, fbo, 1.)
fbo.color_buffer = rbo
fbo.depth_buffer = RenderBuffer(shape)
fbo.stencil_buffer = None
print((fbo.color_buffer, fbo.depth_buffer, fbo.stencil_buffer))
clear(color='black')
with fbo:
clear(color='black')
draw_texture(orig_tex)
out_rbo = _screenshot()[:, :, 0].astype(np.float32)
assert_allclose(data * 255., out_tex, atol=1)
assert_allclose(data * 255., out_rbo, atol=1)
def on_initialize(self, event):
# Build cube data
# --------------------------------------
texcoord = [(0, 0), (0, 1), (1, 0), (1, 1)]
vertices = [(-2, -1, 0), (-2, +1, 0), (+2, -1, 0), (+2, +1, 0)]
vertices = VertexBuffer(vertices)
camera_pitch = 0.0 # Degrees
self.rotate = [camera_pitch, 0, 0]
self.translate = [0, 0, -3]
# Build program
# --------------------------------------
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
scale(model, 1, 1, 1)
self.phi = 0
self.cube = Program(cube_vertex, cube_fragment)
self.cube['position'] = vertices
# 4640 x 2256
imtex = cv2.imread(os.path.join(img_path, 'stage.jpg'))
self.cube['texcoord'] = texcoord
self.cube["texture"] = np.uint8(
np.clip(imtex + np.random.randint(-60, 20, size=imtex.shape), 0,
255)) + 5
self.cube["texture"].interpolation = 'linear'
self.cube['model'] = model
self.cube['view'] = view
color = Texture2D((640, 640, 3), interpolation='linear')
self.framebuffer = FrameBuffer(color, RenderBuffer((640, 640)))
self.quad = Program(quad_vertex, quad_fragment)
self.quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad['texture'] = color
self.objects = [self.cube]
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self.pub_timer = app.Timer(0.1, connect=self.send_ros_img, start=True)
self._set_projection(self.size)
def on_initialize(self, event):
# Build programs
# --------------
self.comp_size = (512, 512)
size = self.comp_size + (4, )
Z = np.zeros(size, dtype=np.float32)
Z[...] = np.random.randint(0, 2, size)
Z[:256, :256, :] = 0
gun = """
........................O...........
......................O.O...........
............OO......OO............OO
...........O...O....OO............OO
OO........O.....O...OO..............
OO........O...O.OO....O.O...........
..........O.....O.......O...........
...........O...O....................
............OO......................"""
x, y = 0, 0
for i in range(len(gun)):
if gun[i] == '\n':
y += 1
x = 0
elif gun[i] == 'O':
Z[y, x] = 1
x += 1
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["texture"] = Z
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dx'] = 1.0 / size[1]
self.compute['dy'] = 1.0 / size[0]
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
def __init__(self):
app.Canvas.__init__(self,
title='Framebuffer post-processing',
keys='interactive',
size=(512, 512))
# Build cube data
# --------------------------------------
vertices, indices, _ = create_cube()
vertices = VertexBuffer(vertices)
self.indices = IndexBuffer(indices)
# Build program
# --------------------------------------
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -7)
self.phi, self.theta = 60, 20
rotate(model, self.theta, 0, 0, 1)
rotate(model, self.phi, 0, 1, 0)
self.cube = Program(cube_vertex, cube_fragment)
self.cube.bind(vertices)
self.cube["texture"] = checkerboard()
self.cube["texture"].interpolation = 'linear'
self.cube['model'] = model
self.cube['view'] = view
color = Texture2D((512, 512, 3), interpolation='linear')
self.framebuffer = FrameBuffer(color, RenderBuffer((512, 512)))
self.quad = Program(quad_vertex, quad_fragment, count=4)
self.quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad['texture'] = color
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self._set_projection(self.size)
def __init__(self, text, canvas, position=1, color=(0.1, 0.0, 0.7)):
'''
Give this the
- text to be written
- main app.canvas
- position (1-9, or which button position this should occupy)
'''
# State Controller
State.register_button(position, text)
self.position = position
self.canvas = canvas
self.projection = np.eye(4)
self.view = np.eye(4)
self.model = np.eye(4)
height, width = 5.0, 15.0 # Meters
orientation_vector = (1, 1, 0)
unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm(
orientation_vector)
scale_factor = 0.2
lowest_button = -5.2
midset = 0.2
scale(self.model, scale_factor)
yrotate(self.model, -60)
# rotate(self.model, 30, *unit_orientation_angle)
offset = (position * ((height + midset) * scale_factor))
translate(self.model, -7.4, lowest_button + offset, -10)
pixel_to_length = 10
self.size = map(lambda o: pixel_to_length * o, [width, height])
# Add texture coordinates
# Rectangle of height height
self.vertices = np.array([
[-width / 2, -height / 2, 0],
[width / 2, -height / 2, 0],
[width / 2, height / 2, 0],
[-width / 2, height / 2, 0],
],
dtype=np.float32)
self.tex_coords = np.array([
[0, 0],
[1, 0],
[1, 1],
[0, 1],
],
dtype=np.float32)
self.indices = IndexBuffer([
0,
1,
2,
2,
3,
0,
])
self.program = Program(self.button_vertex_shader,
self.button_fragment_shader)
self.program['vertex_position'] = self.vertices
self.program['default_texcoord'] = self.tex_coords
self.program['view'] = self.view
self.program['model'] = self.model
self.program['projection'] = self.projection
self.program['background_color'] = color
self.program['highlighted'] = 0
# self.texture = Texture2D(shape=(1000, 1000) + (3,))
# self.text_buffer = FrameBuffer(self.texture, RenderBuffer((1000, 1000)))
self.texture = Texture2D(shape=(500, 1500) + (3, ))
self.text_buffer = FrameBuffer(self.texture, RenderBuffer((500, 1500)))
self.program['texture'] = self.texture
self.text = text
self.make_text(self.text)
self.first = True
def test_renderbuffer():
# Set with no args
assert_raises(ValueError, RenderBuffer)
# Set shape only
R = RenderBuffer((10, 20))
assert R.shape == (10, 20)
assert R.format is None
# Set both shape and format
R = RenderBuffer((10, 20), 'color')
assert R.shape == (10, 20)
assert R.format is 'color'
#
glir_cmds = R._glir.clear()
assert len(glir_cmds) == 2
assert glir_cmds[0][0] == 'CREATE'
assert glir_cmds[1][0] == 'SIZE'
# Orther formats
assert RenderBuffer((10, 20), 'depth').format == 'depth'
assert RenderBuffer((10, 20), 'stencil').format == 'stencil'
# Test reset size and format
R.resize((9, 9), 'depth')
assert R.shape == (9, 9)
assert R.format == 'depth'
R.resize((8, 8), 'stencil')
assert R.shape == (8, 8)
assert R.format == 'stencil'
# Wrong formats
assert_raises(ValueError, R.resize, (9, 9), 'no_format')
assert_raises(ValueError, R.resize, (9, 9), [])
# Resizable
R = RenderBuffer((10, 20), 'color', False)
assert_raises(RuntimeError, R.resize, (9, 9), 'color')
# Attaching sets the format
F = FrameBuffer()
#
R = RenderBuffer((9, 9))
F.color_buffer = R
assert F.color_buffer is R
assert R.format == 'color'
#
F.depth_buffer = RenderBuffer((9, 9))
assert F.depth_buffer.format == 'depth'
#
F.stencil_buffer = RenderBuffer((9, 9))
assert F.stencil_buffer.format == 'stencil'
def test_framebuffer():
# Test init with no args
F = FrameBuffer()
glir_cmds = F._glir.clear()
assert len(glir_cmds) == 1
glir_cmds[0][0] == 'CREATE'
# Activate / deactivate
F.activate()
glir_cmd = F._glir.clear()[-1]
assert glir_cmd[0] == 'FRAMEBUFFER'
assert glir_cmd[2] is True
#
F.deactivate()
glir_cmd = F._glir.clear()[-1]
assert glir_cmd[0] == 'FRAMEBUFFER'
assert glir_cmd[2] is False
#
with F:
pass
glir_cmds = F._glir.clear()
assert len(glir_cmds) == 2
assert glir_cmds[0][0] == 'FRAMEBUFFER'
assert glir_cmds[1][0] == 'FRAMEBUFFER'
assert glir_cmds[0][2] is True and glir_cmds[1][2] is False
# Init with args
R = RenderBuffer((3, 3))
F = FrameBuffer(R)
assert F.color_buffer is R
#
R2 = RenderBuffer((3, 3))
F.color_buffer = R2
assert F.color_buffer is R2
# Wrong buffers
F = FrameBuffer()
assert_raises(TypeError, FrameBuffer.color_buffer.fset, F, 'FOO')
assert_raises(TypeError, FrameBuffer.color_buffer.fset, F, [])
assert_raises(TypeError, FrameBuffer.depth_buffer.fset, F, 'FOO')
assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, F, 'FOO')
color_buffer = RenderBuffer((9, 9), 'color')
assert_raises(ValueError, FrameBuffer.depth_buffer.fset, F, color_buffer)
# But None is allowed!
F.color_buffer = None
# Shape
R1 = RenderBuffer((3, 3))
R2 = RenderBuffer((3, 3))
R3 = RenderBuffer((3, 3))
F = FrameBuffer(R1, R2, R3)
assert F.shape == R1.shape
assert R1.format == 'color'
assert R2.format == 'depth'
assert R3.format == 'stencil'
# Resize
F.resize((10, 10))
assert F.shape == (10, 10)
assert F.shape == R1.shape
assert F.shape == R2.shape
assert F.shape == R3.shape
assert R1.format == 'color'
assert R2.format == 'depth'
assert R3.format == 'stencil'
# Shape from any buffer
F.color_buffer = None
assert F.shape == (10, 10)
F.depth_buffer = None
assert F.shape == (10, 10)
F.stencil_buffer = None
assert_raises(RuntimeError, FrameBuffer.shape.fget, F)
# Also with Texture luminance
T = gloo.Texture2D((20, 30))
R = RenderBuffer(T.shape)
assert T.format == 'luminance'
F = FrameBuffer(T, R)
assert F.shape == T.shape[:2]
assert F.shape == R.shape
assert T.format == 'luminance'
assert R.format == 'depth'
# Resize
F.resize((10, 10))
assert F.shape == (10, 10)
assert T.shape == (10, 10, 1)
assert F.shape == R.shape
assert T.format == 'luminance'
assert R.format == 'depth'
# Also with Texture RGB
T = gloo.Texture2D((20, 30, 3))
R = RenderBuffer(T.shape)
assert T.format == 'rgb'
F = FrameBuffer(T, R)
assert F.shape == T.shape[:2]
assert F.shape == R.shape
assert T.format == 'rgb'
assert R.format == 'depth'
# Resize
F.resize((10, 10))
assert F.shape == (10, 10)
assert T.shape == (10, 10, 3)
assert F.shape == R.shape
assert T.format == 'rgb'
assert R.format == 'depth'
# Wrong shape in resize
assert_raises(ValueError, F.resize, (9, 9, 1))
assert_raises(ValueError, F.resize, (9, ))
assert_raises(ValueError, F.resize, 'FOO')
def __init__(self):
self.projection = np.eye(4)
self.view = np.eye(4)
self.model = np.eye(4)
height, width = 3.0, 6.0
scale_factor = 0.2
x_offset = -8
y_offset = 2
pixel_to_length = 10
color = (1.0, 1.0, 1.0)
scale(self.model, scale_factor)
yrotate(self.model, -60)
translate(self.model, x_offset, y_offset, -10)
size = (int(height * 100), int(width * 100))
self.vertices = np.array([
[-width / 2, -height / 2, 0],
[width / 2, -height / 2, 0],
[width / 2, height / 2, 0],
[-width / 2, height / 2, 0],
],
dtype=np.float32)
self.tex_coords = np.array([
[0, 0],
[1, 0],
[1, 1],
[0, 1],
],
dtype=np.float32)
self.indices = IndexBuffer([
0,
1,
2,
2,
3,
0,
])
self.program = Program(self.battery_vertex_shader,
self.battery_fragment_shader)
self.texture = Texture2D(shape=size + (3, ))
self.text_buffer = FrameBuffer(self.texture, RenderBuffer(size))
images = []
images.append(
Image.open(
os.path.join(Paths.get_path_to_visar(), 'visar', 'images',
'battery', 'battery_low_color.png')))
images.append(
Image.open(
os.path.join(Paths.get_path_to_visar(), 'visar', 'images',
'battery', 'battery_used_color.png')))
images.append(
Image.open(
os.path.join(Paths.get_path_to_visar(), 'visar', 'images',
'battery', 'battery_full_color.png')))
self.level_texture = {} # texture for each level
for x in range(0, len(images)):
default_image = images[x]
default_image = default_image.rotate(-90)
default_image = default_image.resize(size)
default_image = default_image.transpose(Image.FLIP_TOP_BOTTOM)
default_image_array = np.asarray(default_image)
self.level_texture[x + 1] = default_image_array
#default_image_array = imageio.imread(os.path.join(Paths.get_path_to_visar(), 'visar', 'images', 'battery', 'battery_full_color.png'))
# self.default_tex = Texture2D(data=default_image_array)
# self.default_tex = Texture2D(shape=size + (3,))
# self.default_tex.set_data(self.level_texture[3])
self.program['vertex_position'] = self.vertices
self.program['default_texcoord'] = self.tex_coords
self.program['view'] = self.view
self.program['model'] = self.model
self.program['projection'] = self.projection
self.program['hide'] = 0
# self.tex_program = Program(self.tex_vert_shader, self.battery_fragment_shader)
# self.tex_program['vertex_position'] = self.vertices
# self.tex_program['default_texcoord'] = self.tex_coords
# self.tex_program['hide'] = 0
# self.tex_program['texture'] = self.default_tex
self.flag = True # flag to update the texture
self.level = 3 # level of the battery 1 - 3
full_middle_split = 75 # split between levels 2 and 3
middle_low_split = 25 # split between levels 1 and 2
fault_tolerance = 5
self.full_lower = full_middle_split - fault_tolerance # lower limit for going from 3 to 2
self.middle_upper = full_middle_split + fault_tolerance # upper limit for going from 2 to 3
self.middle_lower = middle_low_split - fault_tolerance # lower limit for going from 2 to 1
self.low_upper = middle_low_split + fault_tolerance # upper limit for going from 1 to 2
def on_initialize(self, event):
# Build cube data
# --------------------------------------
texcoord = [(0, 0), (0, 1), (1, 0), (1, 1)]
vertices = [(-1, -1, 0), (-1, +1, 0), (+1, -1, 0), (+1, +1, 0)]
vertices = VertexBuffer(vertices)
#self.listener.waitForTransform("/robot", "/wrist_joint", rospy.Time(), rospy.Duration(4))
"""while not rospy.is_shutdown():
try:
now = rospy.Time.now()
self.listener.waitForTransform("/wrist_joint", "/robot", rospy.Time(), rospy.Duration(4))
(trans,rot) = listener.lookupTransform("/wrist_joint", "/robot", rospy.Time(), rospy.Duration(4))
"""
#pos, rot = self.listener.lookupTransform("/wrist_joint", "/robot", rospy.Time(0))
#print list(pos)
camera_pitch = 0.0 # Degrees
self.rotate = [camera_pitch, 0, 0]
#self.translate = list(pos)
self.translate = [0, 0, -5]
# Build program
# --------------------------------------
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
scale(model, 10, 10, 10)
self.phi = 0
self.cube = Program(cube_vertex, cube_fragment)
self.cube['position'] = vertices
# 4640 x 2256
imtex = cv2.imread(os.path.join(img_path, 'rubixFront.jpg'))
self.cube['texcoord'] = texcoord
self.cube["texture"] = np.uint8(np.clip(imtex + np.random.randint(-60, 20, size=imtex.shape), 0, 255)) + 5
self.cube["texture"].interpolation = 'linear'
self.cube['model'] = model
self.cube['view'] = view
color = Texture2D((640, 640, 3), interpolation='linear')
self.framebuffer = FrameBuffer(color, RenderBuffer((640, 640)))
self.quad = Program(quad_vertex, quad_fragment)
self.quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad['texture'] = color
self.objects = [self.cube]
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self.pub_timer = app.Timer(0.1, connect=self.send_ros_img, start=True)
self._set_projection(self.size)
def __init__(self, canvas, background_color=(0,0,0,0), text_color=(1,1,1)):
# State.register_button(position, text)
self.canvas = canvas
self.text = None
self.tcolor = (text_color[0],text_color[1],text_color[2], 1)
self.bcolor = background_color
self.timer = 0
self.fade_timer = 0
self.projection = np.eye(4)
self.view = np.eye(4)
self.model = np.eye(4)
height, width = 5.0, 15.0 # Meters
orientation_vector = (1, 1, 0)
unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm(orientation_vector)
scale_factor = 0.4
lowest_button = -5.2
midset = 0.2
position = -2
scale(self.model, scale_factor)
#yrotate(self.model, -90)
# rotate(self.model, 30, *unit_orientation_angle)
offset = (position * ((height + midset) * scale_factor))
translate(self.model, -4.4, lowest_button + offset, -10)
self.size = (int(height*100), int(width*100))
# Add texture coordinates
# Rectangle of height height
self.vertices = np.array([
[-width / 2, -height / 2, 0],
[ width / 2, -height / 2, 0],
[ width / 2, height / 2, 0],
[-width / 2, height / 2, 0],
], dtype=np.float32)
self.tex_coords = np.array([
[0, 0],
[1, 0],
[1, 1],
[0, 1],
], dtype=np.float32)
self.indices = IndexBuffer([
0, 1, 2,
2, 3, 0,
])
self.program = Program(self.toast_vertex_shader, self.toast_fragment_shader)
self.program['vertex_position'] = self.vertices
self.program['default_texcoord'] = self.tex_coords
self.program['view'] = self.view
self.program['model'] = self.model
self.program['projection'] = self.projection
self.program['background_color'] = (0,0,0,0) # no background yet
self.program['text_color'] = (0,0,0,0) # no text yet
# self.texture = Texture2D(shape=(1000, 1000) + (3,))
# self.text_buffer = FrameBuffer(self.texture, RenderBuffer((1000, 1000)))
self.texture = Texture2D(shape=self.size + (3,))
self.text_buffer = FrameBuffer(self.texture, RenderBuffer(self.size))
self.program['texture'] = self.texture
#self.program['text_color'] = self.tcolor # set the tcolor
#self.program['background_color'] = self.bcolor # set the tcolor
self.first = False # do not draw text until needed
self.make_text('Default Text') # Create Empty text object