def make_window(image_fn, size, title=None, cleanup=True):
"""Return a glumpy app.Window with standard settings"""
app.use('glfw')
config = app.configuration.Configuration()
config.major_version = 3
config.minor_version = 2
config.profile = "core"
window = app.Window(int(size[0]),
int(size[1]),
title or '',
config=config,
vsync=True)
@window.event
def on_draw(dt):
window.set_title('fps: {}'.format(window.fps).encode('ascii'))
image_fn()
if cleanup:
@window.event
def on_close():
for stream in streams:
stream.stop_stream()
stream.close()
audio.terminate()
for shell in shells:
shell.ex('exit()')
sys.exit(0)
return window
def __init__(self, width=512, height=256):
window = app.Window(width=width, height=height,
color=(0.0, 0.0, 0.0, 1.00))
self.programs = []
framebuffer = np.zeros((window.height, window.width * 3), dtype=np.uint8)
self.first = True # Why this need self?
@window.event
def on_draw(dt):
window.clear()
for program_object in self.programs:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.tri)
if self.first:
print('First')
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('yolo.png', my_texture)
#png.from_array(my_texture, 'RGB').save('screenshot{}.png'.format(1))
self.first = False
@window.event
def on_resize(width, height):
pass
@window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def add_window(cls,
width: int = 500,
height: int = 500,
title: str = None,
color: list = [1, 1, 1, 1]):
# make title of the window
if title is None:
title = 'window' + str(len(cls.WINDOWS) + 1)
else:
title = title
new_window = app.Window(width=width,
height=height,
title=title,
color=color)
# run default initiation
@new_window.event
def on_init():
pass
@new_window.event
def on_resize(width: int, height: int):
pass
# insert window to the window dictionary(self.WINDOWS)
cls.WINDOWS[title] = new_window
print(f'___ new window {title} MADE')
def init_window(self):
window = app.Window(width=1920,
height=1080,
color=(0.30, 0.30, 0.35, 1.00))
@window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glPolygonOffset(1, 1)
gl.glEnable(gl.GL_LINE_SMOOTH)
gl.glLineWidth(0.55)
@window.event
def on_draw(dt):
window.clear()
self.on_draw(dt)
@window.event
def on_resize(width, height):
program = self.program
program['projection'] = glm.perspective(45.0,
width / float(height), 0.1,
100.0)
self.window = window
def __init__(self, model_folder, K, width=640, height=480, zNear=0.25, zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
self.render_kernel = gloo.Program(vertex, fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
self.render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
self.render_kernel['u_projection'] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
global trans
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def main():
vertex = """
attribute vec2 position;
void main (void)
{
gl_Position = vec4(position, 0.0, 1.0);
}
"""
fragment = open('/tmp/tt.fs').read()
app.use('glfw')
window = app.Window(width=640, height=480)
@window.event
def on_draw(dt):
quad['time'] += dt * .5
window.clear()
quad.draw(gl.GL_TRIANGLE_STRIP)
title = 'FPS:%f' % (clock.get_fps())
window.set_title(title)
quad = gloo.Program(vertex, fragment, count=4)
quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
quad['resolution'] = [window.width, window.height]
quad['time'] = 0
app.run()
def __init__(self, init_f, per_frame_f, width=512, height=512):
"""
constructor for the GLWindow object
:param init_f: function to initialize window with, should return a float tensor in format:
[batch_size, channels, height, width] with values between -1 and 1
:param per_frame_f: function run per frame to update window,
takes current frame as argument and should return then next frame
as a float tensor in format: [batch_size, channels, height, width]
:param width: Width of the window in pixels
:param height: Height of the window in pixels
"""
# create window with OpenGL context
self.init_f = init_f
self.per_frame_f = per_frame_f
app.use('glfw')
window = app.Window(width, height, fullscreen=False)
self.window = window
self.setup()
@window.event
def on_draw(dt):
global state
self.window.set_title(str(self.window.fps).encode("ascii"))
tex = screen['tex']
h, w = tex.shape[:2]
# mutate state in torch
img = self.per_frame_f(
state).detach() # prevent autograd from filling memory
# convert into proper format
tensor = img.squeeze().transpose(0, 2)
tensor = tensor.transpose(0, 1).data # put in texture order
tensor = torch.cat((tensor, tensor[:, :, 0].unsqueeze(2)),
2) # add the alpha channel
tensor[:, :, 3] = 1 # set alpha
# check that tensor order matches texture:
tensor = (255 *
tensor).byte().contiguous() # convert to ByteTensor
# copy from torch into buffer
assert tex.nbytes == tensor.numel() * tensor.element_size()
with self.cuda_activate(cuda_buffer) as ary:
cpy = pycuda.driver.Memcpy2D()
cpy.set_src_device(tensor.data_ptr())
cpy.set_dst_array(ary)
cpy.width_in_bytes = cpy.src_pitch = cpy.dst_pitch = tex.nbytes // h
cpy.height = h
cpy(aligned=False)
torch.cuda.synchronize()
# draw to screen
self.window.clear()
screen.draw(gl.GL_TRIANGLE_STRIP)
def __init__(self, figsize=(10, 10), dpi=72, color=(.95, .95, .95, 1)):
width = int(round(figsize[0] * dpi))
height = int(round(figsize[1] * dpi))
self.window = app.Window(width=width,
height=height,
color=color,
title="Figure (matplotlib API)")
self.viewport = app.Viewport()
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
self.rgb_buffer = np.zeros((self.height, self.width, 4),
dtype=np.float32)
self.depth_buffer = np.zeros((self.height, self.width),
dtype=np.float32)
log.info("Loading mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernel = gloo.Program(self.vertex, self.fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel["u_texture"] = np.copy(
data.load("{}/texture_map.png".format(model_folder))[::-1, :, :])
self.render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
self.render_kernel["u_projection"] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
print("self.window: ", self.window)
print("self.render_kernel at init: ", self.render_kernel)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.draw(gl.GL_TRIANGLES)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA,
gl.GL_FLOAT, self.rgb_buffer)
gl.glReadPixels(
0,
0,
self.width,
self.height,
gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT,
self.depth_buffer,
)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def widowSetting():
window = app.Window(1024, 1024, color=(0, 0, 0, 1))
framebuffer = np.zeros((window.height, window.width * 3), dtype=np.uint8)
@window.event
def on_draw(dt):
window.clear()
# Filled program_cube
program_ptCloud.draw(gl.GL_POINTS)
# Make program_cube rotate
program_ptCloud['u_model'] = matrix_model()
def matrix_model():
model = np.eye(4, dtype=np.float32)
#model *= size
glm.rotate(model, theta, 1, 0, 0)
glm.rotate(model, -phi, 0, 1, 0)
#glm.translate(model, -phi/100, -theta/100, 0)
glm.scale(model, size)
#model[3,3] = 1
return model
@window.event
def on_resize(width, height):
ratio = width / float(height)
program_ptCloud['u_projection'] = glm.perspective(
45.0, ratio, 0.001, 10000.0)
@window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
@window.event
def on_mouse_scroll(x, y, dx, dy):
global zoom, size
size += dy * 0.1
if size < 0:
size = 0.1
#zoom += dy*1
#program_ptCloud['u_view'] = glm.translation(0, 0, zoom)
@window.event
def on_mouse_drag(x, y, dx, dy, button):
global theta, phi
theta += dy # degrees
phi -= dx # degrees
@window.event
def on_key_press(symbol, modifiers):
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
#print('Key pressed (symbol=%s, modifiers=%s)'% (symbol,modifiers))
program_ptCloud['color_sel'] = 1 - program_ptCloud['color_sel']
app.run()
def render_depth(model, im_size, K, R, t, clip_near=100, clip_far=2000):
assert ({'pts', 'faces'}.issubset(set(model.keys())))
shape = (im_size[1], im_size[0])
# --------------------------------------------- Create buffers ----------------------------------------
colors = np.ones((model['pts'].shape[0], 3), np.float32) * 0.5
vertices_type = [('a_position', np.float32, 3),
('a_color', np.float32, colors.shape[1])]
vertices = np.array(list(zip(model['pts'], colors)), vertices_type)
vertex_buffer = vertices.view(gloo.VertexBuffer)
index_buffer = model['faces'].flatten().astype(np.uint32).view(gloo.IndexBuffer)
# --------------------------------------------- Model matrix ------------------------------------------
mat_model = np.eye(4, dtype=np.float32) # From object space to world space
# View matrix (transforming also the coordinate system from OpenCV to
# OpenGL camera space)
mat_view = np.eye(4, dtype=np.float32) # From world space to eye space
mat_view[:3, :3], mat_view[:3, 3] = R, t.squeeze()
yz_flip = np.eye(4, dtype=np.float32)
yz_flip[1, 1], yz_flip[2, 2] = -1, -1
mat_view = yz_flip.dot(mat_view) # OpenCV to OpenGL camera system
mat_view = mat_view.T # OpenGL expects column-wise matrix format
# Projection matrix
mat_proj = _compute_calib_proj(K, 0, 0, im_size[0], im_size[1], clip_near, clip_far)
# --------------------------------------------- Create window ------------------------------------------
# config = app.configuration.Configuration()
# Number of samples used around the current pixel for multisample
# anti-aliasing (max is 8)
# config.samples = 8
# config.profile = "core"
# window = app.Window(config=config, visible=False)
window = app.Window(visible=False)
global rgb, depth
rgb = None
depth = None
@window.event
def on_draw(dt):
window.clear()
# Render depth image
global depth
depth = draw_depth(shape, vertex_buffer, index_buffer, mat_model,
mat_view, mat_proj)
app.run(framecount=0) # The on_draw function is called framecount+1 times
window.close()
return depth
def __init__(
self,
model_path,
texture_path,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.7],
):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_path = model_path
log.info("Loading mesh")
vertices, indices = data.objload("{}".format(model_path), rescale=True)
vertices["position"] = vertices["position"] / 10.0
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel["u_texture"] = np.copy(
data.load("{}".format(texture_path))[::-1, :, :])
render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel["u_projection"] = np.copy(u_projection)
render_kernel["u_light_intensity"] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def widowSetting():
window = app.Window(1024,1024, color=(1,1,1,1))
@window.event
def on_draw(dt):
window.clear()
points.draw()
window.attach(points["transform"])
window.attach(points["viewport"])
app.run()
def __init__(self,
width,
height,
mode='rgb+depth',
shading='phong',
bg_color=(0.0, 0.0, 0.0, 0.0)):
"""Constructor.
:param width: Width of the rendered image.
:param height: Height of the rendered image.
:param mode: Rendering mode ('rgb+depth', 'rgb', 'depth').
:param shading: Type of shading ('flat', 'phong').
:param bg_color: Color of the background (R, G, B, A).
"""
super(RendererPython, self).__init__(width, height)
self.mode = mode
self.shading = shading
self.bg_color = bg_color
# Indicators whether to render RGB and/or depth image.
self.render_rgb = self.mode in ['rgb', 'rgb+depth']
self.render_depth = self.mode in ['depth', 'rgb+depth']
# Structures to store object models and related info.
self.models = {}
self.model_bbox_corners = {}
self.model_textures = {}
# Rendered images.
self.rgb = None
self.depth = None
# Window for rendering.
self.window = app.Window(visible=False)
# Per-object vertex and index buffer.
self.vertex_buffers = {}
self.index_buffers = {}
# Per-object OpenGL programs for rendering of RGB and depth images.
self.rgb_programs = {}
self.depth_programs = {}
# The frame buffer object.
rgb_buf = np.zeros((self.height, self.width, 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((self.height, self.width),
np.float32).view(gloo.DepthTexture)
self.fbo = gloo.FrameBuffer(color=rgb_buf, depth=depth_buf)
# Activate the created frame buffer object.
self.fbo.activate()
def __init__(self, class_name_list, model_folder_dict, K, width=640, height=480, zNear=0.25, zFar=6.0, brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder_dict = model_folder_dict
self.class_name_list = class_name_list
self.render_kernels = {} # self.render_kernels[class_name][brightness_ratio]
for cls_name in class_name_list:
if cls_name == "__background__":
continue
model_folder = model_folder_dict[cls_name]
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
if not cls_name in self.render_kernels.keys():
self.render_kernels[cls_name] = []
for brightness_ratio in brightness_ratios:
print('class_name: {}, brightness_ratio: {}, model_folder: {}'.format(cls_name, brightness_ratio,
model_folder))
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels[cls_name].append(render_kernel)
self.class_name = class_name_list[-1]
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.class_name][self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def make_window(self):
""" Create the application window """
window = app.Window(title=self.title,
width=self.width,
height=self.height,
color=self.bg_color)
window.set_handler('on_draw', self.on_draw)
window.set_handler('on_init', self.on_init)
window.set_handler('on_resize', self.on_resize)
window.set_handler('on_close', partial(self.on_close,
caller=self.title))
return window
def _run(self):
window = app.Window()
@window.event
def on_init():
# FIXME: it doesn't work here, so it' has been duplicated in the main cycle
gl.glEnable(gl.GL_DEPTH_TEST)
@window.event
def on_resize(width, height):
ratio = width / float(height)
self._scene.set_camera_projection(45.0, ratio, 2.0, 100.0)
@window.event
def on_draw(dt):
window.clear()
if dt == 0:
return
# ensure that depth test is enabled
gl.glEnable(gl.GL_DEPTH_TEST)
# rotate cube
try:
rotation_matrix = np.eye(4, dtype=np.float32)
glm.rotate(
rotation_matrix,
angle=self.angle * self._RAD_TO_DEG_K,
x=self.x,
y=self.y,
z=self.z
)
self._rotation_matrix[...] = rotation_matrix
except Exception as e:
logger.error(e)
# draw scene
self._scene.draw()
@window.event
def on_close():
print("Window has been closed", file=sys.stderr)
sys.exit(1)
backend = app.__backend__
clock = app.__init__(backend=backend)
clock.set_fps_limit(30)
count = len(backend.windows())
while count:
count = backend.process(clock.tick())
if not self._active:
break
with suppress(Exception):
window.close()
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading brain mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading brain texture")
render_kernel['u_texture'] = np.copy(
data.load(
"{}/texture_map.png".format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def run(self):
app.use('glfw')
self.window = app.Window(height=self.h, width=self.w, fullscreen=False)
self.window.push_handlers(on_draw=self.on_draw)
self.window.push_handlers(on_close=self.on_close)
import pycuda.gl.autoinit
import pycuda.gl
tex, cuda_buffer = create_shared_texture(self.w, self.h, 4)
self.tex = tex
self.cuda_buffer = cuda_buffer
self.screen_program = get_screen_program(tex)
app.run(framerate=self.max_framerate)
def __init__(self, model_path_list, texture_path, K, width=640, height=480, zNear=0.25, zFar=6.0, brightness_ratios=[0.7]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_path_list = model_path_list
self.model_path = model_path_list[0]
self.render_kernels = {model_path: [] for model_path in model_path_list}
log.info("Loading mesh")
for model_i, model_path in enumerate(model_path_list):
print('loading model: {}/{}, {}'.format(model_i+1, len(model_path_list), model_path))
vertices, indices = data.objload("{}"
.format(model_path), rescale=True)
vertices['position'] = vertices['position'] / 10.
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel['u_texture'] = np.copy(data.load("{}"
.format(texture_path))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels[model_path].append(render_kernel)
print('************Finish loading models in Render_Py_Light_ModelNet_Multi********************')
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernels[self.model_path][self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self, args, fragment=None, winsize=None, title=None):
self.fps = args.fps
self.record = args.record
self.old_program = None
if fragment is None:
fragment = args.fragment
if winsize:
args.winsize = list(map(int, winsize))
self.title = title
self.load_program(fragment, args.export)
self.params = args.params
if self.params:
self.program_params = set(self._params.keys()).intersection(
set(self.params.keys())) - {"mods"}
else:
self.params = self._params
self.program_params = set(self._params.keys()) - {"mods"}
self.iMat = self.params.get("iMat")
# Gimbal mode, always looking at the center
self.gimbal = True
if self.gimbal:
self.params.setdefault("horizontal_angle", 0.)
self.params.setdefault("vertical_angle", 0.)
self.params.setdefault("distance", 10.)
if self.iMat is not None:
self.horizontal_angle = self.params.get("horizontal_angle", 0.)
self.vertical_angle = self.params.get("vertical_angle", 0.)
self.setDirection()
if self.gimbal:
self.position = np.array([.0, .0, self.params["distance"]])
else:
self.position = np.array([.0, .0, 10.2])
if title != "Map":
self.controller = Controller(self.params, default={})
else:
self.controller = None
self.screen = app.Window(width=args.winsize[0],
height=args.winsize[1],
title=title)
super().__init__(args.winsize, self.screen)
if self.controller:
self.controller.set(self.screen, self)
self.screen.attach(self)
self.paused = False
self.prev_params = {}
def run(self):
app.use('glfw')
self.window = app.Window(height=self.h, width=self.w, fullscreen=False)
self.window.push_handlers(on_draw=self.on_draw)
self.window.push_handlers(on_close=self.on_close)
self.state2 = torch.ones((self.h, self.w, 4), dtype=torch.uint8, device=torch.device('cuda:0')) * 128
self.state2[:, :, 1] = 255
import pycuda.gl.autoinit
import pycuda.gl
tex, cuda_buffer = create_shared_texture(self.w, self.h, 4)
self.tex = tex
self.cuda_buffer = cuda_buffer
self.screen_program = get_screen_program(tex)
app.run(framerate=self.max_framerate)
def run(self):
app.use("qt5")
self.window = app.Window(width=self.width, height=self.height)
#self.window = app.Window()
self.window.attach(self)
#app.clock.set_fps_limit(20)
clock = app.__init__(backend=app.__backend__)
if False:
with record(self.window, "cube.mp4", fps=20):
app.run(framerate=20)
else:
while True:
#dt = clock.tick()
#self.program1['time'] = dt*5
time.sleep(0.01)
app.__backend__.process(0.05)
if self.finish:
return
def __init__(self,
model,
im_size,
texture=None,
bg_color=(0.0, 0.0, 0.0, 0.0),
ambient_weight=0.5,
shading='flat',
mode='rgb+depth'):
# Set texture / color of vertices
texture_uv = np.zeros((model['pts'].shape[0], 2), np.float32)
colors = np.ones((model['pts'].shape[0], 3), np.float32) * 0.5
# Set the vertex data
vertices_type = [('a_position', np.float32, 3),
('a_normal', np.float32, 3),
('a_color', np.float32, colors.shape[1]),
('a_texcoord', np.float32, 2)]
vertices = np.array(
list(zip(model['pts'], model['normals'], colors, texture_uv)),
vertices_type)
# Create buffers
self.vertex_buffer = vertices.view(gloo.VertexBuffer)
self.index_buffer = model['faces'].flatten().astype(np.uint32).view(
gloo.IndexBuffer)
self.window = app.Window(visible=False)
self.program = gloo.Program(_normal_vertex_code, _normal_fragment_code)
self.program.bind(self.vertex_buffer)
scale = max(im_size)
shape = (scale, scale)
color_buf = np.zeros((shape[0], shape[1], 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((shape[0], shape[1]),
np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3])
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glViewport(0, 0, shape[1], shape[0])
gl.glDisable(gl.GL_CULL_FACE)
def draw(fx):
window = app.Window(width=800, height=800, color=(1,1,1,1))
pos, rad, col = next(fx)
n = len(rad)
program = gloo.Program(vertex, fragment, count=n)
view = np.eye(4, dtype=np.float32)
glm.translate(view, 0, 0, -5)
program['position'] = pos
program['radius'] = rad
program['fg_color'] = 0,0,0,1
program['bg_color'] = col
program['linewidth'] = 1.0
program['antialias'] = 1.0
program['model'] = np.eye(4, dtype=np.float32)
program['projection'] = np.eye(4, dtype=np.float32)
program['view'] = view
@window.event
def on_draw(dt):
global theta, phi
program['position'], program['radius'], program['bg_color'] = next(fx)
window.clear()
program.draw(gl.GL_POINTS)
theta += .5
phi += .5
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
program['model'] = model
@window.event
def on_resize(width,height):
program['projection'] = glm.perspective(45.0, width / float(height), 1.0, 1000.0)
gl.glEnable(gl.GL_DEPTH_TEST)
app.run()
def main():
window = app.Window(width=800, height=800, color=(1, 1, 1, 1))
protein = gloo.Program(vertex, fragment)
protein['light_position'] = 0., 0., 2.
protein["transform"] = Trackball(Position())
protein.bind(data.get("protein.npy").view(gloo.VertexBuffer))
protein['color'] *= .25
protein['color'] += .75
@window.event
def on_draw(dt):
window.clear()
protein.draw(gl.GL_POINTS)
@window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
window.attach(protein["transform"])
app.run()
def __init__(self, width=512, height=256):
window = app.Window(width=width,
height=height,
color=(0.0, 0.0, 0.0, 1.00))
framebuffer = np.zeros((window.height, window.width * 3),
dtype=np.uint8)
self.programMulti, self.programIdx = [], 0
self.first = True # Why this need self?
@window.event
def on_draw(dt):
for programSingle_idx, programSingle in enumerate(
self.programMulti):
print(programSingle_idx)
window.clear()
for program_object in programSingle:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode,
program_object.tri)
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer,
(window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave(
'{:d}_{:d}.png'.format(self.programIdx, programSingle_idx),
my_texture)
window.close()
@window.event
def on_resize(width, height):
pass
@window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def display_cloud(cloud):
window = app.Window(width=800, height=800, color=(1, 1, 1, 1))
@window.event
def on_draw(dt):
global theta, phi, translate
window.clear()
program.draw(gl.GL_POINTS)
theta += .5
phi += .5
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
program['model'] = model
@window.event
def on_resize(width, height):
program['projection'] = glm.perspective(45.0, width / float(height),
1.0, 1000.0)
n = len(cloud)
program = gloo.Program(vertex, fragment, count=n)
view = np.eye(4, dtype=np.float32)
glm.translate(view, 0, 0, -5)
program['position'] = cloud
program['radius'] = [5] * n
program['fg_color'] = 0, 0, 0, 1
colors = np.random.uniform(0.75, 1.00, (n, 4))
colors[:, 3] = 1
program['bg_color'] = colors
program['linewidth'] = 1.0
program['antialias'] = 1.0
program['model'] = np.eye(4, dtype=np.float32)
program['projection'] = np.eye(4, dtype=np.float32)
program['view'] = view
gl.glEnable(gl.GL_DEPTH_TEST)
app.run()
from math import *
import Mesh
myMesh = Mesh.Mesh()
print(myMesh.nV)
print(myMesh.nF)
myMesh.load('truck.txt', ply=True, normalize=True)
print(myMesh.nV)
print(myMesh.nF)
asp = 1.0
angle = 0.0
cur_time = -1.0
window = app.Window(700, 600, "hello")
def cameraLensSet(ratio=1.0):
# camera lens 설정
glMatrixMode(GL_PROJECTION)
glLoadIdentity() # 기본 렌즈 설정
gluPerspective(60, ratio, 0.01, 100) # y 시야각, 종횡비, 가까운 면, 먼 면
glClearColor(1.0, 0.0, 0.0, 1.0) # RGBA
@window.event
def on_draw(dt):
global angle, cur_time
old_time = cur_time
# Minimize the model, and move the camera-view back
glm.scale(model, 0.5, 1, 0.1)
glm.translate(view, 0, 0, -5)
# Pass all the matrix to the model
cube['u_model'] = model
cube['u_view'] = view
cube['u_projection'] = projection
cube["u_light_position"] = 0, 0, -2
cube["u_light_intensity"] = 1, 1, 1
# Initiaze the window
phi = 0.5
theta = 0.1
kappa = 1
window = app.Window(800, 600)
@window.event
def on_resize(width, height):
global projection
ratio = width / float(height)
projection = glm.perspective(45.0, ratio, 2.0, 100.0)
cube['u_projection'] = projection
@window.event
def on_draw(dt):
global phi, theta, model
