def app(render, width=1280, height=720, window_name="Maldives"):
"""
:param render:
:param width:
:param height:
:param window_name:
:return:
"""
imgui.create_context()
window = impl_glfw_init(width, height, window_name)
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
gl.glClearColor(0.3, 0.5, 0.4, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
impl.process_inputs()
imgui.new_frame()
render()
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def start(self):
imgui.create_context()
io = imgui.get_io()
# io.fonts.add_font_default()
io.fonts.add_font_from_file_ttf(
"./res/font/Roboto-Medium.ttf", 14,
io.fonts.get_glyph_ranges_chinese_full())
io.fonts.add_font_from_file_ttf(
"./res/font/FZY3JW.ttf", 13,
io.fonts.get_glyph_ranges_chinese_full(), True)
self.window = App._impl_glfw_init()
impl = GlfwRenderer(self.window)
while not glfw.window_should_close(self.window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
# imgui.show_test_window()
self.update()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(self.window)
self.main_view and self.main_view.on_close()
impl.shutdown()
glfw.terminate()
def main(recfile):
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
slamgui = SLAMGUI(recfile)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item("Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
imgui.end_main_menu_bar()
slamgui.render()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
impl = GlfwRenderer(window)
font_scaling_factor = fb_to_window_factor(window)
io = impl.io
# clear font atlas to avoid downscaled default font
# on highdensity screens. First font added to font
# atlas will become default font.
io.fonts.clear()
# set global font scaling
io.font_global_scale = 1. / font_scaling_factor
# dictionary of font objects from our font directory
fonts = {
os.path.split(font_path)[-1]: io.fonts.add_font_from_file_ttf(
font_path, FONT_SIZE_IN_PIXELS * font_scaling_factor,
io.fonts.get_glyph_ranges_latin())
for font_path in FONTS_DIR
}
secondary_window_main_font = random.choice(list(fonts.values()))
impl.refresh_font_texture()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.begin("Window with multiple custom fonts", True)
imgui.text("This example showcases font usage on text() widget")
for font_name, font in fonts.items():
imgui.separator()
imgui.text("Font:{}".format(font_name))
with imgui.font(font):
imgui.text("This text uses '{}' font.".format(font_name))
imgui.end()
with imgui.font(secondary_window_main_font):
imgui.begin("Window one main custom font", True)
imgui.text("This window uses same custom font for all widgets")
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
class Application:
def __init__(self, args):
imgui.create_context()
self._window = self._glfw_init()
self._renderer = GlfwRenderer(self._window)
self._scene = TinyRendererEditor()
self.main_loop()
def main_loop(self):
while not glfw.window_should_close(self._window):
glfw.poll_events()
self._renderer.process_inputs()
imgui.new_frame()
gl.glClearColor(0.2, 0.2, 0.2, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self._scene.update()
imgui.render()
draw_data = imgui.get_draw_data()
if draw_data.valid:
self._renderer.render(draw_data)
glfw.swap_buffers(self._window)
self._renderer.shutdown()
glfw.terminate()
def _glfw_init(self):
"""
Initializes the glfw an OpenGL context and returns a window
"""
width, height = 1600, 900
window_name = "Computer Graphics Playground"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# OS X supports only forward-compatible core profiles from 3.2
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
return window
def __init__(self):
"""Initialise a program and start a rendering loop
This creates a glfw window + an imgui context
This also then handles an update and rendering loop
Raises:
EnvironmentError: if GLFW fails to initialize
EnvironmentError: if GLFW fails to creat a window
"""
if not glfw.init():
raise EnvironmentError("Failed to initialize GLFW.")
# Create window
window = glfw.create_window(1600, 900, "Hello World!", None, None)
if not window:
glfw.terminate()
raise EnvironmentError("Failed to create window.")
# Add in an imgui context for debugging / UIs
glfw.make_context_current(window)
imgui.create_context()
impl = ImGuiGlfwRenderer(window)
# Build the scene and load resources
self.buildScene()
currentTime = glfw.get_time()
# Window loop
while not glfw.window_should_close(window):
# Calculate delta time
prevTime = currentTime
currentTime = glfw.get_time()
delta = currentTime - prevTime
# Identify which keys are being pressed
keyStates = {}
for name, id in glfwKeyNames.items():
keyStates[name] = glfw.get_key(window, id) == glfw.PRESS
# Pass off to sub functions
self.update(delta, keyStates)
self.render(window)
self.ui(window)
# Render imgui stuff
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
glfw.poll_events()
impl.process_inputs()
# Exit gracefully once glfw wants to close the window
glfw.terminate()
def main():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
ip_address = "localhost:3333"
#imgui.set_window_font_scale(1.0)
comms = MouseSocket()
click_guard = True
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.set_next_window_size(300, 120)
imgui.set_next_window_position(10, 0)
imgui.begin("", False, imgui.WINDOW_NO_RESIZE)
changed, ip_address = imgui.input_text(label="IP:PORT",
value=ip_address,
buffer_length=30)
clicked = imgui.button(label="CONNECT")
if clicked:
comms.connect(ip_address)
max_x, max_y = glfw.get_window_size(window)
x, y = glfw.get_cursor_pos(window)
norm_x = x / max_x
norm_y = y / max_y
state = glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_LEFT)
if state == glfw.PRESS:
click_guard = False
elif state == glfw.RELEASE and not click_guard:
click_guard = True
comms.send_click(norm_x, norm_y)
comms.send_mouse_coords(norm_x, norm_y)
imgui.text("Mouse Coords: {:.2f}, {:.2f}".format(norm_x, norm_y))
imgui.text("Connected: {}".format(comms.is_connected))
imgui.end()
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
desktop = Desktop()
imgui.create_context()
window = core.impl_glfw_init()
impl = GlfwRenderer(window)
imgui.core.style_colors_light()
app_list = list(get_app_list())
# figure = plt.figure()
# img = Image.open('./test.png')
# texture, width, height = readImage(img)
def update():
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("System", True):
for app in app_list:
clicked, selected = imgui.menu_item(
app.__name__, '', False, True)
if clicked:
desktop.add(app())
imgui.separator()
clicked_quit, selected_quit = imgui.menu_item(
"Quit", '', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
desktop.render()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
update()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
data = imgui.get_draw_data()
impl.render(data)
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
_ = gl.glGenFramebuffers(1)
videoWindows = []
def dropFile(window, files):
for file in files:
videoWindows.append(VideoPlayer(file))
glfw.set_drop_callback(window, dropFile)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
videoWindows = [x for x in videoWindows if x.open]
if len(videoWindows) > 0:
for videoWindow in videoWindows:
videoWindow.render()
else:
imgui.core.set_next_window_position(10, 10)
winw, winh = glfw.get_window_size(window)
imgui.core.set_next_window_size(winw - 20, 10)
imgui.begin("##Message",
True,
flags=imgui.WINDOW_NO_SCROLLBAR
| imgui.WINDOW_NO_RESIZE | imgui.WINDOW_NO_TITLE_BAR
| imgui.WINDOW_NO_MOVE)
imgui.text("Drop one or more video files onto this window to play")
imgui.end()
gl.glClearColor(0., 0., 0., 1.)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
for videoWindow in videoWindows:
videoWindow.terminate()
impl.shutdown()
glfw.terminate()
def main():
window = impl_glfw_init()
imgui.create_context()
impl = GlfwRenderer(window)
plot_values = array('f', [sin(x * C) for x in range(L)])
histogram_values = array('f', [random() for _ in range(20)])
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
imgui.begin("Plot example")
imgui.plot_lines(
"Sin(t)",
plot_values,
overlay_text="SIN() over time",
# offset by one item every milisecond, plot values
# buffer its end wraps around
values_offset=int(time() * 100) % L,
# 0=autoscale => (0, 50) = (autoscale width, 50px height)
graph_size=(0, 50),
)
imgui.plot_histogram(
"histogram(random())",
histogram_values,
overlay_text="random histogram",
# offset by one item every milisecond, plot values
# buffer its end wraps around
graph_size=(0, 50),
)
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
ctx = imgui.create_context()
implot.create_context()
implot.set_imgui_context(ctx)
window = impl_glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.begin("Custom window", True)
imgui.text("Bar")
imgui.text_ansi("B\033[31marA\033[mnsi ")
imgui.text_ansi_colored("Eg\033[31mgAn\033[msi ", 0.2, 1., 0.)
imgui.extra.text_ansi_colored("Eggs", 0.2, 1., 0.)
imgui.end()
# show_test_window()
imgui.show_test_window()
implot.show_demo_window()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
class HelloTriangleImgui(OpenGLApp):
def __init__(self):
super().__init__("Hello Triangle with ImGui")
self._vao = 0
self._shader_program = None
self._ui = None
def initialize(self):
vertices = np.array([-0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0], dtype=np.float32)
self._vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self._vao)
vbo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, vertices, GL.GL_STATIC_DRAW)
GL.glVertexAttribPointer(0, 3, GL.GL_FLOAT, GL.GL_FALSE, 3 * ctypes.sizeof(ctypes.c_float), None)
GL.glEnableVertexAttribArray(0)
GL.glBindVertexArray(0)
vertex_shader = Shader(GL.GL_VERTEX_SHADER, "shaders_src/hello_triangle_vertex.glsl")
fragment_shader = Shader(GL.GL_FRAGMENT_SHADER, "shaders_src/hello_triangle_frag.glsl")
self._shader_program = ShaderProgram(vertex_shader, fragment_shader)
vertex_shader.delete()
fragment_shader.delete()
imgui.create_context()
self._ui = GlfwRenderer(self._window, False)
def render(self):
self._shader_program.use()
GL.glBindVertexArray(self._vao)
GL.glDrawArrays(GL.GL_TRIANGLES, 0, 3)
def render_ui(self):
imgui.new_frame()
imgui.show_demo_window()
imgui.render()
self._ui.render(imgui.get_draw_data())
self._ui.process_inputs()
def replay(fname):
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
replaygui = ReplayGUI(fname)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
if imgui.begin_menu("View", True):
_, replaygui.show_frontview = imgui.menu_item(
"Front view", selected=replaygui.show_frontview)
imgui.end_menu()
if imgui.begin_menu("Tools", True):
clicked, _ = imgui.menu_item("Learn control params")
if clicked:
replaygui.learn_controls = True
clicked, _ = imgui.menu_item("Lap timer")
if clicked:
replaygui.lap_timer = True
imgui.end_menu()
imgui.end_main_menu_bar()
replaygui.render()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
class Gui:
def __init__(self, window):
imgui.create_context()
self.impl = GlfwRenderer(window)
self.color = 0.45, 0.55, 0.60, 1.00
def NewFrame(self):
self.impl.process_inputs()
imgui.new_frame()
def EndFrame(self):
imgui.end_frame()
imgui.render()
self.impl.render(imgui.get_draw_data())
def endGui(self):
self.impl.shutdown()
class Gui(object, IRuntimeModule):
def __init__(self):
super(Gui, self).__init__()
self.impl = None # type: Optional[GlfwRenderer]
self.on_gui = None
self.io = None
self.on_gui_editor = None
# ---------------------------------------------------
# IRuntimeModule
# ---------------------------------------------------
@logger
def initialize(self):
imgui.create_context()
self.io = imgui.get_io()
# TODO 这些枚举搜不到，需要式再说
# io.ConfigFlags |= ImGuiConfigFlags_DockingEnable; // Enable Docking
# io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; // Enable Multi-Viewport / Platform Windows
# self.io.config_flags |= imgui.CONFIG_NAV_ENABLE_KEYBOARD # Enable Keyboard Controls TODO cause error
window = G.appm.window_handle
self.impl = GlfwRenderer(
window, attach_callbacks=False
) # NOTE otherwise imgui will register glfw callbacks
imgui.style_colors_dark()
self.on_gui = G.appm.on_gui
self.on_gui_editor = G.editorm.on_gui
@logger
def finalize(self):
self.impl.shutdown()
imgui.destroy_context()
def update(self):
self.impl.process_inputs()
imgui.new_frame()
self.on_gui and self.on_gui()
self.on_gui_editor and self.on_gui_editor()
imgui.render()
self.impl.render(imgui.get_draw_data())
def sim():
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
sg = SimGUI()
t0 = time.time()
play = True
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, _ = imgui.menu_item("Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(0)
imgui.end_menu()
imgui.end_main_menu_bar()
t = time.time()
if play:
sg.step(min(t - t0, 0.03))
else:
sg.idle()
t0 = t
play = sg.render(play)
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main_glfw():
def glfw_init():
width, height = 1280, 720
window_name = "minimal ImGui/GLFW3 example"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# OS X supports only forward-compatible core profiles from 3.2
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(
int(width), int(height), window_name, None, None
)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
return window
window = glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
on_frame()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
init()
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
draw(imgui)
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def main():
global width_library
global width_shematic
global width_context
global height_window
global previous_key_callback
global selected_link
global selected_node
global iggraph
global node_library
global debug_is_mouse_dragging
global show_debug_window
# states -------------------------
scrolling = imgui.Vec2(0, 0)
iggraph = IGGraph(node_library)
# iggraph.reset()
node_hovered_in_scene = -1
parameter_link_start = None
selected_parameter = None
io_hovered = None
io_anchors_width_not_hovered = 10
io_anchors_width_hovered = 15
right_splitter_is_active = False
left_splitter_is_active = False
image_width = 0
image_height = 0
image_texture = None
# states -------------------------
imgui.create_context()
window = impl_glfw_init()
impl = GlfwRenderer(window)
io = imgui.get_io()
previous_key_callback = glfw.set_key_callback(window,key_event)
init_textures()
assign_parameter_colors(node_library)
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_new, selected_new = imgui.menu_item(
"New", 'Cmd+N', False, True
)
if clicked_new:
iggraph = IGGraph(node_library)
clicked_load, selected_load = imgui.menu_item(
"Load", 'Cmd+L', False, True
)
if clicked_load:
root = tk.Tk()
root.withdraw()
filename = filedialog.askopenfilename()
if filename :
f=open(filename)
iggraph.from_json(json.load(f))
f.close()
clicked_save, selected_save = imgui.menu_item(
"Save", 'Cmd+S', False, True
)
if clicked_save:
iggraph.reset()
graph_json = iggraph.to_json()
text2save = json.dumps(graph_json, indent=4, sort_keys=True)
root = tk.Tk()
root.withdraw()
f = filedialog.asksaveasfile(mode='w', defaultextension=".json")
if f is None: # asksaveasfile return `None` if dialog closed with "cancel".
return
f.write(text2save)
f.close()
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True
)
if clicked_quit:
exit(0)
imgui.end_menu()
if imgui.begin_menu("Debug", True):
show_debug_window_clicked, show_debug_window_selected = imgui.menu_item(
"Show Debug window", 'Cmd+D', show_debug_window, True
)
if show_debug_window_clicked:
show_debug_window = not show_debug_window
catch_exceptions_clicked, catch_exceptions_selected = imgui.menu_item(
"Catch Exceptions", '', iggraph.catch_exceptions, True
)
if catch_exceptions_clicked:
iggraph.catch_exceptions = not iggraph.catch_exceptions
imgui.separator()
imgui.menu_item(
"Examples", '', False, False
)
show_example_mosaic_clicked, show_example_mosaic_selected = imgui.menu_item(
"Mosaic", '', False, True
)
if show_example_mosaic_clicked:
example_mosaic(iggraph)
imgui.end_menu()
imgui.end_main_menu_bar()
height_window = io.display_size.y - 18 # imgui.get_cursor_pos_y()
imgui.push_style_var(imgui.STYLE_ITEM_SPACING, imgui.Vec2(0,0))
imgui.set_next_window_size(io.display_size.x, height_window)
imgui.set_next_window_position(0, 18)
imgui.push_style_var(imgui.STYLE_WINDOW_ROUNDING, 0)
imgui.begin("Splitter test", False, imgui.WINDOW_NO_TITLE_BAR | imgui.WINDOW_NO_RESIZE | imgui.WINDOW_NO_MOVE | imgui.WINDOW_NO_BRING_TO_FRONT_ON_FOCUS)
imgui.pop_style_var()
imgui.pop_style_var()
width_shematic = io.display_size.x - separator_width - width_context - separator_width - width_library
# ==============================================================================
# Library
# ==============================================================================
imgui.push_style_var(imgui.STYLE_CHILD_BORDERSIZE, 0)
imgui.begin_child("Library", width_library, 0, True)
for node_name in node_library.nodes:
if imgui.button(node_name, width_library):
iggraph.create_node(node_name)
imgui.end_child()
imgui.pop_style_var()
imgui.same_line()
imgui.button("left_splitter", separator_width, height_window - 20)
left_splitter_is_active = imgui.is_item_active()
if (left_splitter_is_active):
width_library += io.mouse_delta.x
scrolling = imgui.Vec2(scrolling.x - io.mouse_delta.x, scrolling.y)
if (imgui.is_item_hovered()):
imgui.set_mouse_cursor(imgui.MOUSE_CURSOR_RESIZE_EW)
imgui.same_line()
# ==============================================================================
# Shematic
# ==============================================================================
imgui.push_style_var(imgui.STYLE_CHILD_BORDERSIZE, 0)
imgui.begin_child("shematic", width_shematic, 0, True)
if show_inputs_popup(iggraph):
imgui.open_popup("Outputs")
show_outputs_popup(iggraph)
# create our child canvas
if iggraph.get_state() == iggraph.STATE_IDLE:
imgui.text("status: edit | ")
elif iggraph.get_state() == iggraph.STATE_RUNNING:
imgui.text("status: run | ")
imgui.same_line()
if iggraph.get_state() == iggraph.STATE_IDLE:
if imgui.button("run"):
#TODO if not running
iggraph.set_state(iggraph.STATE_RUNNING)
iggraph.prepare_to_run()
imgui.open_popup("User Input")
imgui.same_line()
if imgui.button("run one step"):
iggraph.set_state(iggraph.STATE_RUNNING)
iggraph.prepare_to_run()
iggraph.run_one_step()
elif iggraph.get_state() == iggraph.STATE_RUNNING:
if imgui.button("stop running"):
iggraph.reset()
iggraph.set_state(iggraph.STATE_IDLE)
imgui.same_line()
if imgui.button("run one step"):
iggraph.set_state(iggraph.STATE_RUNNING)
iggraph.run_one_step()
# imgui.same_line(imgui.get_window_width() - 100)
imgui.push_style_var(imgui.STYLE_FRAME_PADDING, imgui.Vec2(1, 1))
imgui.push_style_var(imgui.STYLE_WINDOW_PADDING, imgui.Vec2(0, 0))
imgui.begin_child("scrolling_region", 0, 0, True, imgui.WINDOW_NO_SCROLLBAR | imgui.WINDOW_NO_MOVE)
imgui.pop_style_var()
imgui.pop_style_var()
imgui.push_item_width(120.0)
offset = add(imgui.get_cursor_screen_pos(), scrolling)
draw_list = imgui.get_window_draw_list()
# Display links
draw_list.channels_split(2)
draw_list.channels_set_current(0)
for link in iggraph.links:
draw_link_param_to_param(draw_list, offset, link.output_parameter, link.input_parameter, selected_link == link)
# Display nodes
parameter_link_end = None
one_parameter_hovered = False
one_node_moving_active = False
for node in iggraph.nodes:
imgui.push_id(str(node.id))
node_rect_min = add(offset, node.pos)
draw_list.channels_set_current(1) # foreground
old_any_active = imgui.is_any_item_active()
#display node content first
# todo
test = add(node_rect_min, NODE_WINDOW_PADDING)
imgui.set_cursor_screen_position(add(node_rect_min, NODE_WINDOW_PADDING))
imgui.begin_group()
imgui.text("")
imgui.text(node.name)
imgui.text("")
imgui.end_group()
# save size
node_widgets_active = False # (not old_any_active and imgui.is_any_item_active())
node.size = add( add( imgui.get_item_rect_size(), NODE_WINDOW_PADDING) , NODE_WINDOW_PADDING)
node_rect_max = add(node.size, node_rect_min)
#display node box
draw_list.channels_set_current(0) # background
imgui.set_cursor_screen_position(node_rect_min)
imgui.invisible_button(str(node.id), node.size.x, node.size.y)
if imgui.is_item_hovered():
node_hovered_in_scene = node.id
else:
node_hovered_in_scene = None
node_moving_active = imgui.is_item_active()
use_hovered_color = node_hovered_in_scene or selected_node == node
draw_list.add_rect_filled(node_rect_min.x, node_rect_min.y, node_rect_max.x, node_rect_max.y, get_node_color(node, iggraph, use_hovered_color), 5)
if node_hovered_in_scene and iggraph.is_error(node):
imgui.begin_tooltip()
imgui.text(iggraph.error_nodes[node])
imgui.end_tooltip()
# input parameters
for parameter_name in node.inputs:
parameter = node.inputs[parameter_name]
center = node.get_intput_slot_pos(parameter)
center_with_offset = add(offset, center)
if io_hovered == parameter:
io_anchors_width = io_anchors_width_hovered
else:
io_anchors_width = io_anchors_width_not_hovered
imgui.set_cursor_pos(imgui.Vec2(center.x-io_anchors_width/2, center.y-io_anchors_width/2))
imgui.push_id(str(str(node.id) + "input" + parameter.id))
if (imgui.invisible_button("input", io_anchors_width, io_anchors_width)):
selected_parameter = parameter
# imgui.is_item_hovered() does not work when dragging
is_hovering = ((io.mouse_pos.x-offset.x>center.x-io_anchors_width/2) and
(io.mouse_pos.x-offset.x<center.x+io_anchors_width/2) and
(io.mouse_pos.y-offset.y>center.y-io_anchors_width/2) and
(io.mouse_pos.y-offset.y<center.y+io_anchors_width/2))
if is_hovering:
io_hovered = parameter
one_parameter_hovered = True
imgui.begin_tooltip()
imgui.text(parameter_name)
imgui.end_tooltip()
if is_hovering and imgui.is_mouse_released(0):
parameter_link_end = parameter
imgui.pop_id()
draw_list.add_circle_filled(center_with_offset.x, center_with_offset.y, io_anchors_width/2, get_parameter_color(parameter))
# output parameters
for parameter_name in node.outputs:
parameter = node.outputs[parameter_name]
center = node.get_output_slot_pos(parameter)
center_with_offset = add(offset, center)
if io_hovered == parameter:
io_anchors_width = io_anchors_width_hovered
else:
io_anchors_width = io_anchors_width_not_hovered
imgui.set_cursor_pos(imgui.Vec2(center.x-io_anchors_width/2, center.y-io_anchors_width/2))
imgui.push_id(str(str(node.id) + "output" + parameter.id))
if (imgui.invisible_button("output", io_anchors_width, io_anchors_width)):
selected_parameter = parameter
is_hovering = ((io.mouse_pos.x-offset.x>center.x-io_anchors_width/2) and
(io.mouse_pos.x-offset.x<center.x+io_anchors_width/2) and
(io.mouse_pos.y-offset.y>center.y-io_anchors_width/2) and
(io.mouse_pos.y-offset.y<center.y+io_anchors_width/2))
if is_hovering:
io_hovered = parameter
one_parameter_hovered = True
imgui.begin_tooltip()
imgui.text(parameter_name)
imgui.end_tooltip()
draw_list.add_circle_filled(center_with_offset.x, center_with_offset.y, io_anchors_width/2, get_parameter_color(parameter))
imgui.pop_id()
# cannot use imgui.is_item_active, seems buggy with the scroll
if is_hovering and imgui.is_mouse_down(0):
parameter_link_start = parameter
if node_widgets_active or node_moving_active:
selected_node = node
one_node_moving_active = True
if node_moving_active and imgui.is_mouse_dragging(0) and node.id==selected_node.id:
node.pos = add(node.pos, io.mouse_delta)
debug_is_mouse_dragging = imgui.is_mouse_dragging(0)
imgui.pop_id()
draw_list.channels_merge()
if not one_parameter_hovered:
io_hovered = None
# scrolling
mouse_is_in_schematic = (io.mouse_pos.x > width_library) and\
(io.mouse_pos.x < (width_library + width_shematic)) and\
(io.mouse_pos.y < height_window) and\
(io.mouse_pos.y > 18)
if not one_node_moving_active and\
not parameter_link_start and\
imgui.is_mouse_dragging(0) and\
mouse_is_in_schematic and\
not left_splitter_is_active and\
not right_splitter_is_active and\
imgui.is_window_focused():
scroll_offset = imgui.Vec2(io.mouse_delta.x, io.mouse_delta.y)
scrolling = add(scrolling, scroll_offset)
# link creation
if parameter_link_start and parameter_link_end:
iggraph.add_link(parameter_link_start, parameter_link_end)
# creating link
elif parameter_link_start and imgui.is_mouse_dragging(0):
draw_link_param_to_point(draw_list, offset, parameter_link_start, io.mouse_pos.x, io.mouse_pos.y, True)
# mouse release
if imgui.is_mouse_released(0):
parameter_link_start = None
imgui.pop_item_width()
imgui.end_child()
# mouse click on the scene
if imgui.is_mouse_clicked(0):
mouse_pos = imgui.get_mouse_pos()
local_mouse_pos = imgui.Vec2(mouse_pos.x - offset.x, mouse_pos.y - offset.y)
selected_link = None
for link in iggraph.links:
start_node = link.output_parameter.owner
start_pos = start_node.get_output_slot_pos(link.output_parameter)
end_node = link.input_parameter.owner
end_pos = end_node.get_intput_slot_pos(link.input_parameter)
distance_mouse_start = math.sqrt(((local_mouse_pos.x-start_pos.x)**2) + ((local_mouse_pos.y-start_pos.y)**2))
distance_mouse_end = math.sqrt(((local_mouse_pos.x-end_pos.x)**2) + ((local_mouse_pos.y-end_pos.y)**2))
distance_start_end = math.sqrt(((start_pos.x-end_pos.x)**2) + ((start_pos.y-end_pos.y)**2))
if ((distance_mouse_start + distance_mouse_end) - distance_start_end) < 0.1:
selected_link = link
imgui.end_child()
imgui.pop_style_var()
imgui.same_line()
imgui.button("right_splitter", separator_width, height_window - 20)
right_splitter_is_active = imgui.is_item_active()
if (right_splitter_is_active):
width_context -= io.mouse_delta.x
if (imgui.is_item_hovered()):
imgui.set_mouse_cursor(imgui.MOUSE_CURSOR_RESIZE_EW)
# ==============================================================================
# Context
# ==============================================================================
imgui.same_line()
imgui.push_style_var(imgui.STYLE_CHILD_BORDERSIZE, 0)
imgui.begin_child("child3", width_context, 0, True);
if selected_node:
if selected_node.handle_dynamic_parameters():
if imgui.button("add parameter"):
selected_node.add_dynamic_parameter()
if imgui.tree_node("Inputs"):
for parameter_name in selected_node.inputs:
parameter = selected_node.inputs[parameter_name]
if imgui.tree_node(parameter.id):
display_parameter(parameter, True)
imgui.tree_pop()
imgui.tree_pop()
if imgui.tree_node("Output"):
for parameter_name in selected_node.outputs:
parameter = selected_node.outputs[parameter_name]
if imgui.tree_node(parameter.id):
display_parameter(parameter, False)
imgui.tree_pop()
imgui.tree_pop()
imgui.end_child()
imgui.pop_style_var()
#
imgui.end()
# ==============================================================================
# Debug Window
# ==============================================================================
if show_debug_window:
debug_window_expanded, show_debug_window = imgui.begin("Debug", True)
if parameter_link_start:
imgui.text("parameter_link_start: " + parameter_link_start.id)
else:
imgui.text("parameter_link_start: " + "None")
if selected_parameter:
imgui.text("selected_parameter: " + selected_parameter.id)
else:
imgui.text("selected_parameter: " + "None")
imgui.text("is_mouse_dragging: " + str(debug_is_mouse_dragging))
imgui.text("mouse: (" + str(io.mouse_pos.x) + ", " + str(io.mouse_pos.y) + ")")
imgui.end()
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
class App:
def __init__(self, width=640, height=480, title="Hello world"):
imgui.create_context()
if not glfw.init():
return
self.window = glfw.create_window(width, height, title, None, None)
if not self.window:
glfw.terminate()
return
glfw.make_context_current(self.window)
self.ctx = moderngl.create_context(require=460)
self.impl = ImguiRenderer(self.window, attach_callbacks=False)
glfw.set_key_callback(self.window, self._on_key)
glfw.set_cursor_pos_callback(self.window, self._on_mouse_move)
glfw.set_mouse_button_callback(self.window, self._on_mouse_button)
glfw.set_window_size_callback(self.window, self._on_resize)
glfw.set_char_callback(self.window, self._on_char)
glfw.set_scroll_callback(self.window, self._on_scroll)
self.init()
def main_loop(self):
previous_time = glfw.get_time()
# Loop until the user closes the window
while not glfw.window_should_close(self.window):
glfw.poll_events()
self.impl.process_inputs()
current_time = glfw.get_time()
delta_time = current_time - previous_time
previous_time = current_time
self.update(current_time, delta_time)
self.render()
imgui.new_frame()
self.ui()
imgui.render()
self.impl.render(imgui.get_draw_data())
glfw.swap_buffers(self.window)
self.impl.shutdown()
glfw.terminate()
def should_close(self):
glfw.set_window_should_close(self.window, True)
def mouse_pos(self):
return glfw.get_cursor_pos(self.window)
def size(self):
return glfw.get_window_size(self.window)
def init(self):
pass
def update(self, time):
pass
def render(self):
pass
def ui(self):
pass
def _on_key(self, window, key, scancode, action, mods):
self.impl.keyboard_callback(window, key, scancode, action, mods)
self.on_key(key, scancode, action, mods)
def on_key(self, key, scancode, action, mods):
pass
def _on_char(self, window, codepoint):
self.impl.char_callback(window, codepoint)
self.on_char(codepoint)
def on_char(self, codepoint):
pass
def _on_mouse_move(self, window, x, y):
self.impl.mouse_callback(window, x, y)
self.on_mouse_move(x, y)
def on_mouse_move(self, x, y):
pass
def _on_mouse_button(self, window, button, action, mods):
if not imgui.get_io().want_capture_mouse:
self.on_mouse_button(button, action, mods)
def on_mouse_button(self, button, action, mods):
pass
def _on_scroll(self, window, xoffset, yoffset):
self.impl.scroll_callback(window, xoffset, yoffset)
self.on_scroll(xoffset, yoffset)
def on_scroll(self, xoffset, yoffset):
pass
def _on_resize(self, window, width, height):
self.impl.resize_callback(window, width, height)
self.on_resize(width, height)
def on_resize(self, width, height):
pass
glClear(GL_COLOR_BUFFER_BIT)
# imgui function
impl.process_inputs()
locationX, locationY, angle, color = \
transformGuiOverlay(locationX, locationY, angle, color)
# Setting uniforms and drawing the Quad
glUniformMatrix4fv(
glGetUniformLocation(pipeline.shaderProgram, "transform"), 1,
GL_TRUE,
np.matmul(tr.translate(locationX, locationY, 0.0),
tr.rotationZ(angle)))
glUniform3f(
glGetUniformLocation(pipeline.shaderProgram, "modulationColor"),
color[0], color[1], color[2])
pipeline.drawCall(gpuQuad)
# Drawing the imgui texture over our drawing
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
impl.render(imgui.get_draw_data())
# Once the render is done, buffers are swapped, showing only the complete scene.
glfw.swap_buffers(window)
# freeing GPU memory
gpuQuad.clear()
impl.shutdown()
glfw.terminate()
def main():
width, height = Settings.WindowWidth, Settings.WindowHeight
# initialize glfw
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.SAMPLES, 4)
glfw.window_hint(glfw.DEPTH_BITS, 32)
window = glfw.create_window(width, height, "OpenGL Window", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
# glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
# imgui stuff
imgui.create_context()
impl = GlfwRenderer(window)
# Check OpenGL version
print(glGetString(GL_VERSION))
glfw.swap_interval(0)
load = GLTFLoader("resources/gltf/trailer/scene.gltf")
scene = load.get_scene()
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_MULTISAMPLE)
Global.ProjMat = glm.perspective(glm.radians(35), width / height, 1.0,
100000.0)
scene.setup_scene()
grid = GUI.Grid(10, 50)
renderer = Renderer()
translation = glm.vec3(0.0, 0.0, 0.0)
grid = GUI.Grid(10, 50)
rotation = 0.0
increment = 2.0
view = glm.mat4(1.0)
# Camera
cam = GUI.Flycam(glm.vec3(0.0, 150.0, 1000))
# Time & FPS counter
tt = GUI.TimeTracker()
# Input poll
inpt = GUI.Input()
# glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
glfw.set_mouse_button_callback(window, mouse_button_callback)
glfw.set_drop_callback(window, drop_callback)
scene.nodelist[0].transformation = glm.rotate(
scene.nodelist[0].transformation, glm.radians(90), vec3(1.0, 0.0, 0.0))
scene.nodelist[0].transformation = glm.rotate(
scene.nodelist[0].transformation, glm.radians(180),
vec3(0.0, 1.0, 0.0))
while not glfw.window_should_close(window):
# Time & FPS counter
tt.update()
# Input
process_input(window)
inpt.poll_mouse_pos(window)
glfw.poll_events()
# Camera
cam.update(window)
renderer.clear()
glClear(GL_DEPTH_BUFFER_BIT)
# --------Imgui----------
impl.process_inputs()
imgui.new_frame()
GUI.draw_imgui(scene)
imgui.show_demo_window()
# Camera Stuff
Global.ViewMat = cam.get_view()
grid.draw_grid(Global.ProjMat, Global.ViewMat)
scene.draw_scene()
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
impl.shutdown()
glfw.terminate()
def run_reloadable_imgui_app(app_module, no_reload=()):
no_reload = no_reload + (__name__, )
settings = getattr(app_module, '__settings__', {})
window_title = settings.get('window_title', DEFAULT_WINDOW_TITLE)
initial_window_size = settings.get('initital_window_size',
DEFAULT_WINDOW_SIZE)
target_framerate = settings.get('target_framerate',
DEFAULT_TARGET_FRAMERATE)
num_active_frames_after_input = 2 * target_framerate # arbitrary
window = impl_glfw_init(window_title=window_title,
window_size=initial_window_size)
renderer = GlfwRenderer(window)
io = imgui.get_io()
max_frame_dur = 1 / target_framerate
frame_start = 0.
frame_end = 0.
frame_dur = 0.
wait_dur = 0.
prev_mouse_pos = (0, 0)
mouse_pos = (0, 0)
prev_mouse_down_0 = False
prev_frame_click_0_finished = False
frames_since_last_input = 0
# TODO:
def got_input() -> bool:
"""
Checks if the user sent any left-mouse mouse inputs, like moving/clicking the mouse
"""
nonlocal mouse_pos
nonlocal prev_mouse_pos
nonlocal prev_mouse_down_0
nonlocal prev_frame_click_0_finished
mouse_pos = io.mouse_pos
mouse_moved = (mouse_pos != prev_mouse_pos)
mouse_changed = io.mouse_down[0] != prev_mouse_down_0
click_0_finished = prev_mouse_down_0 and (
not io.mouse_down[0]) # mouse was down previous frame, now it's up
# key_clicked = any(io.keys_down)
result = mouse_moved or mouse_changed or io.mouse_down[
0] or prev_frame_click_0_finished # or key_clicked
prev_mouse_pos = mouse_pos
prev_mouse_down_0 = io.mouse_down[0]
prev_frame_click_0_finished = click_0_finished
return result
m_request = None
setattr(app_module, '__was_reloaded__', False)
# reload loop
while True:
# This isn't the render loop yet.
# This one is to enable reloading,
# in which case we need to run init
# and start the render loop again.
# ========================
if hasattr(app_module, '__app_init__'):
app_module.__app_init__()
# ========================
# render loop
while True:
frame_start = glfw.get_time() # seconds
# debug_log("frame_start_ms", frame_start*1000) # miliseconds
glfw.poll_events()
renderer.process_inputs()
if got_input():
frames_since_last_input = 0
else:
frames_since_last_input += 1
if frames_since_last_input <= num_active_frames_after_input:
imgui.new_frame()
# =========================
if hasattr(
app_module, '__pre_frame__'
): # TODO: should this run before imgui.new_frame(?)
app_module.__pre_frame__()
app_module.__draw__()
if hasattr(
app_module, '__post_frame__'
): # TODO: should this run before imgui.end_frame(?)
m_request = app_module.__post_frame__()
# the app's request is processed at the end of the loop
# =========================
gl.glClearColor(1., 1., 1., 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
renderer.render(imgui.get_draw_data())
glfw.swap_buffers(window)
frame_end = glfw.get_time() # seconds
frame_dur = frame_end - frame_start
wait_dur = max_frame_dur - frame_dur
if wait_dur > 0:
sleep(wait_dur)
if m_request in ('reload',
'shutdown') or glfw.window_should_close(window):
break # stop the render loop
# end render loop
# if control flow got to this point, it means that
# the render loop finished. possible reasons:
# - the app requested a reload
# - the app requested a shutdown
# - glfw.window_should_close(window) is true
if glfw.window_should_close(window) or m_request == 'shutdown':
break # end the reload loop, run user shutdown, close
elif m_request == 'reload':
rlu.recursive_reload(app_module,
dir=rlu.module_dirpath(app_module),
excluded=no_reload)
setattr(app_module, '__was_reloaded__', True)
continue
# end reload loop
# =========================
if hasattr(app_module, '__app_shutdown__'):
app_module.__app_shutdown__()
# =========================
renderer.shutdown()
glfw.terminate()
class ImGuiPlayer:
# ---------------------------------------------------------------------------
# --------------------------- class variables -------------------------------
# ---------------------------------------------------------------------------
window = None
impl: GlfwRenderer = None
app: ImGuiPlayerApp = None
quit_requested: bool = None
def __init__(self, app: ImGuiPlayerApp):
self.app = app
#initialize window and GUI
imgui.create_context()
self.window = self.impl_glfw_init()
self.impl = GlfwRenderer(self.window)
self.quit_requested = False
def impl_glfw_init(self):
width, height = 1200, 1200
window_name = "RefocusApp"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 2)
# the OPENGL_COMPAT_PROFILE enables the mix between pyimgui and glumpy
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_COMPAT_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
sys.exit(1)
self.app.window_size_callback(window, 1200, 1200)
return window
# ---------------------------------------------------------------------------
# --------------------------- class methods - gui and menu ----------------
# ---------------------------------------------------------------------------
def key_callback(self, window, key, scancode, action, mods):
io = imgui.get_io()
self.impl.keyboard_callback(window, key, scancode, action, mods)
if io.want_capture_keyboard:
print("imgui handles")
else:
#print("processed by app: key pressed")
if key == glfw.KEY_ESCAPE and action == glfw.RELEASE:
self.quit_requested = True
if key == glfw.KEY_Q and np.bitwise_and(mods, glfw.MOD_CONTROL):
self.quit_requested = True
self.app.key_callback(window, key, scancode, action, mods)
def mouse_cursor_pos_callback(self, window, xpos, ypos):
io = imgui.get_io()
if not io.want_capture_mouse:
self.app.mouse_cursor_pos_callback(window, xpos, ypos)
def mouse_button_callback(self, window, button, action, mods):
io = imgui.get_io()
if io.want_capture_mouse:
print("imgui handles")
else:
self.app.mouse_button_callback(window, button, action, mods)
def mouse_scroll_callback(self, window, xoffset, yoffset):
io = imgui.get_io()
if io.want_capture_mouse:
print("imgui handles")
else:
#print( "processed by app: scroll: {},{}".format( xoffset, yoffset ));
self.app.mouse_scroll_callback(window, xoffset, yoffset)
def window_size_callback(self, window, width, height):
self.app.window_size_callback(window, width, height)
def run(self):
glfw.set_key_callback(self.window, self.key_callback)
glfw.set_cursor_pos_callback(self.window,
self.mouse_cursor_pos_callback)
glfw.set_mouse_button_callback(self.window, self.mouse_button_callback)
glfw.set_scroll_callback(self.window, self.mouse_scroll_callback)
glfw.set_window_size_callback(self.window, self.window_size_callback)
while not glfw.window_should_close(
self.window) and not self.quit_requested:
self.app.on_draw()
glfw.poll_events()
self.impl.process_inputs()
self.app.menu()
gl.glClearColor(0., 0., 0.2, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
self.app.on_draw()
imgui.render()
self.impl.render(imgui.get_draw_data())
glfw.swap_buffers(self.window)
self.impl.shutdown()
glfw.terminate()
def main():
useLiveCamera = True
#gc.disable()
# # transform to convert the image to tensor
# transform = transforms.Compose([
# transforms.ToTensor()
# ])
# # initialize the model
# model = torchvision.models.detection.keypointrcnn_resnet50_fpn(pretrained=True,
# num_keypoints=17)
# # set the computation device
# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# # load the modle on to the computation device and set to eval mode
# model.to(device).eval()
# initialize glfw
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
#creating the window
window = glfw.create_window(1600, 900, "PyGLFusion", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
imgui.create_context()
impl = GlfwRenderer(window)
# rendering
glClearColor(0.2, 0.3, 0.2, 1.0)
# positions texture coords
quad = [
-1.0, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0,
1.0, 1.0, -1.0, 1.0, 0.0, 0.0, 1.0
]
quad = np.array(quad, dtype=np.float32)
indices = [0, 1, 2, 2, 3, 0]
indices = np.array(indices, dtype=np.uint32)
screenVertex_shader = (Path(__file__).parent /
'shaders/ScreenQuad.vert').read_text()
screenFragment_shader = (Path(__file__).parent /
'shaders/ScreenQuad.frag').read_text()
renderShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(screenVertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(screenFragment_shader,
GL_FRAGMENT_SHADER))
# set up VAO and VBO for full screen quad drawing calls
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, 80, quad, GL_STATIC_DRAW)
EBO = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(12))
glEnableVertexAttribArray(1)
# shaders
bilateralFilter_shader = (Path(__file__).parent /
'shaders/bilateralFilter.comp').read_text()
bilateralFilterShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(bilateralFilter_shader,
GL_COMPUTE_SHADER))
alignDepthColor_shader = (Path(__file__).parent /
'shaders/alignDepthColor.comp').read_text()
alignDepthColorShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(alignDepthColor_shader,
GL_COMPUTE_SHADER))
depthToVertex_shader = (Path(__file__).parent /
'shaders/depthToVertex.comp').read_text()
depthToVertexShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(depthToVertex_shader,
GL_COMPUTE_SHADER))
vertexToNormal_shader = (Path(__file__).parent /
'shaders/vertexToNormal.comp').read_text()
vertexToNormalShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertexToNormal_shader,
GL_COMPUTE_SHADER))
raycast_shader = (Path(__file__).parent /
'shaders/raycast.comp').read_text()
raycastShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(raycast_shader, GL_COMPUTE_SHADER))
integrate_shader = (Path(__file__).parent /
'shaders/integrate.comp').read_text()
integrateShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(integrate_shader, GL_COMPUTE_SHADER))
trackP2P_shader = (Path(__file__).parent /
'shaders/p2pTrack.comp').read_text()
trackP2PShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(trackP2P_shader, GL_COMPUTE_SHADER))
reduceP2P_shader = (Path(__file__).parent /
'shaders/p2pReduce.comp').read_text()
reduceP2PShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(reduceP2P_shader, GL_COMPUTE_SHADER))
trackP2V_shader = (Path(__file__).parent /
'shaders/p2vTrack.comp').read_text()
trackP2VShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(trackP2V_shader, GL_COMPUTE_SHADER))
reduceP2V_shader = (Path(__file__).parent /
'shaders/p2vReduce.comp').read_text()
reduceP2VShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(reduceP2V_shader, GL_COMPUTE_SHADER))
LDLT_shader = (Path(__file__).parent / 'shaders/LDLT.comp').read_text()
LDLTShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(LDLT_shader, GL_COMPUTE_SHADER))
# Splatter
globalMapUpdate_shader = (Path(__file__).parent /
'shaders/GlobalMapUpdate.comp').read_text()
globalMapUpdateShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(globalMapUpdate_shader,
GL_COMPUTE_SHADER))
indexMapGenVert_shader = (Path(__file__).parent /
'shaders/IndexMapGeneration.vert').read_text()
indexMapGenFrag_shader = (Path(__file__).parent /
'shaders/IndexMapGeneration.frag').read_text()
IndexMapGenerationShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(indexMapGenVert_shader,
GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(indexMapGenFrag_shader,
GL_FRAGMENT_SHADER))
SurfaceSplattingVert_shader = (
Path(__file__).parent / 'shaders/SurfaceSplatting.vert').read_text()
SurfaceSplattingFrag_shader = (
Path(__file__).parent / 'shaders/SurfaceSplatting.frag').read_text()
SurfaceSplattingShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(SurfaceSplattingVert_shader,
GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(SurfaceSplattingFrag_shader,
GL_FRAGMENT_SHADER))
UnnecessaryPointRemoval_shader = (
Path(__file__).parent /
'shaders/UnnecessaryPointRemoval.comp').read_text()
UnnecessaryPointRemovalShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(UnnecessaryPointRemoval_shader,
GL_COMPUTE_SHADER))
# P2V
expm_shader = (Path(__file__).parent / 'shaders/expm.comp').read_text()
expmShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(expm_shader, GL_COMPUTE_SHADER))
d2c, c2d, K, invK, colK = camera.start(useLiveCamera)
shaderDict = {
'renderShader': renderShader,
'bilateralFilterShader': bilateralFilterShader,
'alignDepthColorShader': alignDepthColorShader,
'depthToVertexShader': depthToVertexShader,
'vertexToNormalShader': vertexToNormalShader,
'raycastVolumeShader': raycastShader,
'integrateVolumeShader': integrateShader,
'trackP2PShader': trackP2PShader,
'reduceP2PShader': reduceP2PShader,
'trackP2VShader': trackP2VShader,
'reduceP2VShader': reduceP2VShader,
'LDLTShader': LDLTShader,
'globalMapUpdate': globalMapUpdateShader,
'indexMapGeneration': IndexMapGenerationShader,
'surfaceSplatting': SurfaceSplattingShader,
'unnecessaryPointRemoval': UnnecessaryPointRemovalShader,
'expm': expmShader
}
bufferDict = {
'p2pReduction': -1,
'p2pRedOut': -1,
'p2vReduction': -1,
'p2vRedOut': -1,
'test': -1,
'outBuf': -1,
'poseBuffer': -1,
'globalMap0': -1,
'globalMap1': -1,
'atomic0': -1,
'atomic1': -1
}
textureDict = {
'rawColor': -1,
'lastColor': -1,
'nextColor': -1,
'rawDepth': -1,
'filteredDepth': -1,
'lastDepth': -1,
'nextDepth': -1,
'refVertex': -1,
'refNormal': -1,
'virtualVertex': -1,
'virtualNormal': -1,
'virtualDepth': -1,
'virtualColor': -1,
'mappingC2D': -1,
'mappingD2C': -1,
'xyLUT': -1,
'tracking': -1,
'volume': -1,
'indexMap': -1
}
fboDict = {'indexMap': -1, 'virtualFrame': -1}
# 'iters' : (2, 5, 10),
fusionConfig = {
'volSize': (128, 128, 128),
'volDim': (1.0, 1.0, 1.0),
'iters': (2, 2, 2),
'initOffset': (0, 0, 0),
'maxWeight': 100.0,
'distThresh': 0.05,
'normThresh': 0.9,
'nearPlane': 0.1,
'farPlane': 4.0,
'maxMapSize': 5000000,
'c_stable': 10.0,
'sigma': 0.6
}
cameraConfig = {
'depthWidth': 640,
'depthHeight': 576,
'colorWidth': 1920,
'colorHeight': 1080,
'd2c': d2c,
'c2d': c2d,
'depthScale': 0.001,
'K': K,
'invK': invK,
'colK': colK
}
textureDict = frame.generateTextures(textureDict, cameraConfig,
fusionConfig)
bufferDict = frame.generateBuffers(bufferDict, cameraConfig, fusionConfig)
colorMat = np.zeros(
(cameraConfig['colorHeight'], cameraConfig['colorWidth'], 3),
dtype="uint8")
useColorMat = False
integrateFlag = True
resetFlag = True
initPose = glm.mat4()
initPose[3, 0] = fusionConfig['volDim'][0] / 2.0
initPose[3, 1] = fusionConfig['volDim'][1] / 2.0
initPose[3, 2] = 0
blankResult = np.array([0, 0, 0, 0, 0, 0], dtype='float32')
glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['poseBuffer'])
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 16 * 4,
glm.value_ptr(initPose))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4, 16 * 4,
glm.value_ptr(glm.inverse(initPose)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 2, 16 * 4,
glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 3, 16 * 4,
glm.value_ptr(glm.mat4(1.0)))
glBufferSubData(GL_SHADER_STORAGE_BUFFER, 16 * 4 * 4, 6 * 4, blankResult)
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
mouseX, mouseY = 0, 0
clickedPoint3D = glm.vec4(fusionConfig['volDim'][0] / 2.0,
fusionConfig['volDim'][1] / 2.0, 0, 0)
sliderDim = fusionConfig['volDim'][0]
#[32 64 128 256 512]
currentSize = math.log2(fusionConfig['volSize'][0]) - 5
volumeStatsChanged = False
currPose = initPose
# splatter stuff
frameCount = 0
fboDict = frame.generateFrameBuffers(fboDict, textureDict, cameraConfig)
initAtomicCount = np.array([0], dtype='uint32')
mapSize = np.array([0], dtype='uint32')
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic0'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, bufferDict['atomic1'])
glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, 4, initAtomicCount)
glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0)
# aa = torch.tensor([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=torch.float32, device=torch.device('cuda'))
# bb = torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], dtype=torch.float32, device=torch.device('cuda'))
# #setup pycuda gl interop needs to be after openGL is init
# import pycuda.gl.autoinit
# import pycuda.gl
# cuda_gl = pycuda.gl
# cuda_driver = pycuda.driver
# from pycuda.compiler import SourceModule
# import pycuda
# pycuda_source_ssbo = cuda_gl.RegisteredBuffer(int(bufferDict['test']), cuda_gl.graphics_map_flags.NONE)
# sm = SourceModule("""
# __global__ void simpleCopy(float *inputArray, float *outputArray) {
# unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
# outputArray[x] = inputArray[x];
# inputArray[x] = 8008.135f;
# }
# """)
# cuda_function = sm.get_function("simpleCopy")
# mappingObj = pycuda_source_ssbo.map()
# data, size = mappingObj.device_ptr_and_size()
# cuda_function(np.intp(aa.data_ptr()), np.intp(data), block=(8, 1, 1))
# mappingObj.unmap()
# glBindBuffer(GL_SHADER_STORAGE_BUFFER, bufferDict['test'])
# tee = glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, 32)
# glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0)
# teeData = np.frombuffer(tee, dtype=np.float32)
# print(teeData)
# modTensor = aa.cpu().data.numpy()
# print(modTensor)
#fusionConfig['initOffset'] = (initPose[3,0], initPose[3,1], initPose[3,2])
# LUTs
#createXYLUT(k4a, textureDict, cameraConfig) <-- bug in this
person.init()
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
sTime = time.perf_counter()
try:
capture = camera.getFrames(useLiveCamera)
if capture.color is not None:
#if useLiveCamera == False:
#if k4a.configuration["color_format"] == ImageFormat.COLOR_MJPG:
# colorMat = cv2.imdecode(capture.color, cv2.IMREAD_COLOR)
# useColorMat = True
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, textureDict['rawColor'])
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
int(cameraConfig['colorWidth']),
int(cameraConfig['colorHeight']),
(GL_RGB, GL_RGBA)[useLiveCamera],
GL_UNSIGNED_BYTE,
(capture.color, colorMat)[useColorMat])
if capture.depth is not None:
glActiveTexture(GL_TEXTURE1)
glBindTexture(GL_TEXTURE_2D, textureDict['rawDepth'])
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
int(cameraConfig['depthWidth']),
int(cameraConfig['depthHeight']), GL_RED,
GL_UNSIGNED_SHORT, capture.depth)
except EOFError:
break
# #smallMat = cv2.pyrDown(colorMat)
# start_time = time.time()
# rotMat = cv2.flip(colorMat, 0)
# pil_image = Image.fromarray(rotMat).convert('RGB')
# image = transform(pil_image)
# image = image.unsqueeze(0).to(device)
# end_time = time.time()
# print((end_time - start_time) * 1000.0)
# with torch.no_grad():
# outputs = model(image)
# output_image = utils.draw_keypoints(outputs, rotMat)
# cv2.imshow('Face detection frame', output_image)
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
person.getPose(textureDict, cameraConfig, capture.color)
frame.bilateralFilter(shaderDict, textureDict, cameraConfig)
frame.depthToVertex(shaderDict, textureDict, cameraConfig,
fusionConfig)
frame.alignDepthColor(shaderDict, textureDict, cameraConfig,
fusionConfig)
frame.vertexToNormal(shaderDict, textureDict, cameraConfig)
frame.mipmapTextures(textureDict)
#currPose = track.runP2P(shaderDict, textureDict, bufferDict, cameraConfig, fusionConfig, currPose, integrateFlag, resetFlag)
currPose = track.runP2V(shaderDict, textureDict, bufferDict,
cameraConfig, fusionConfig, currPose,
integrateFlag, resetFlag)
#mapSize = track.runSplatter(shaderDict, textureDict, bufferDict, fboDict, cameraConfig, fusionConfig, mapSize, frameCount, integrateFlag, resetFlag)
frameCount += 1
if resetFlag == True:
resetFlag = False
integrateFlag = True
imgui.begin("Menu", True)
if imgui.button("Reset"):
fusionConfig['volSize'] = (1 << (currentSize + 5), 1 <<
(currentSize + 5), 1 <<
(currentSize + 5))
fusionConfig['volDim'] = (sliderDim, sliderDim, sliderDim)
currPose, integrateFlag, resetFlag = track.reset(
textureDict, bufferDict, cameraConfig, fusionConfig,
clickedPoint3D)
volumeStatsChanged = False
if imgui.button("Integrate"):
integrateFlag = not integrateFlag
imgui.same_line()
imgui.checkbox("", integrateFlag)
changedDim, sliderDim = imgui.slider_float("dim",
sliderDim,
min_value=0.01,
max_value=5.0)
clickedSize, currentSize = imgui.combo(
"size", currentSize, ["32", "64", "128", "256", "512"])
if imgui.is_mouse_clicked():
if not imgui.is_any_item_active():
mouseX, mouseY = imgui.get_mouse_pos()
w, h = glfw.get_framebuffer_size(window)
xPos = ((mouseX % int(w / 3)) / (w / 3) *
cameraConfig['depthWidth'])
yPos = (mouseY / (h)) * cameraConfig['depthHeight']
clickedDepth = capture.depth[
int(yPos + 0.5),
int(xPos + 0.5)] * cameraConfig['depthScale']
clickedPoint3D = clickedDepth * (
cameraConfig['invK'] * glm.vec4(xPos, yPos, 1.0, 0.0))
volumeStatsChanged = True
if changedDim or clickedSize:
volumeStatsChanged = True
imgui.end()
graphics.render(VAO, window, shaderDict, textureDict)
imgui.render()
impl.render(imgui.get_draw_data())
eTime = time.perf_counter()
#print((eTime-sTime) * 1000, mapSize[0])
glfw.swap_buffers(window)
glfw.terminate()
if useLiveCamera == True:
camera.stop()
class Application:
class UniformHolder:
def __init__(self, program: Program):
self.resolution = program.get_uniform("uResolution")
self.mousePos = program.get_uniform("uMousePos")
self.zoom = program.get_uniform("uZoom")
def _draw(self):
glDrawArrays(GL_QUADS, 0, 4)
def _on_resize(self, window, w, h):
self.width = w
self.height = h
self.uniHolder.resolution.set_update(ivec2(w, h))
glViewport(0, 0, w, h)
def _on_mouse_move(self, window, x, y):
mpos = vec2(x, self.height - y)
diff = mpos - self.prev_mpos
self.prev_mpos = mpos
if glfw.get_mouse_button(
window, glfw.MOUSE_BUTTON_LEFT
) == glfw.PRESS and not imgui.get_io().want_capture_mouse:
self.mvel += 3.0 * diff / self.uniHolder.zoom.value
def _on_scroll(self, window, x, y):
self.zm_vel = y * 3.0
def _init_window(self, width, height, fullscreen):
if not glfw.init():
raise Exception("glfw can not be initialized!")
monitor = None
if fullscreen:
monitor = glfw.get_primary_monitor()
self.window = glfw.create_window(width, height, "Toy", monitor, None)
if not self.window:
raise Exception("glfw window can not be created!")
glfw.set_window_pos(self.window, 50, 50)
glfw.make_context_current(self.window)
glfw.swap_interval(1)
glfw.set_window_size_callback(self.window, self._on_resize)
glfw.set_cursor_pos_callback(self.window, self._on_mouse_move)
glfw.set_scroll_callback(self.window, self._on_scroll)
imgui.create_context()
self.impl = GlfwRenderer(self.window, False)
def __init__(self, fs_path: str, width, height, fullscreen=False):
self._init_window(width, height, fullscreen)
self.program = Program.from_files("res/base.vs.glsl", fs_path)
self.prev_mpos = vec2(0, 0)
self.u_mpos = vec2(0, 0)
self.prev_time = glfw.get_time()
self.mvel = vec2(0, 0)
self.zoom = 0.0
self.zm_vel = 0.0
self.uniHolder = Application.UniformHolder(self.program)
self._on_resize(self.window, width, height)
def __exit__(self, exc_type, exc_val, exc_tb):
self.program.delete()
glfw.terminate()
def __enter__(self):
glClearColor(0, 1, 0, 0)
while not glfw.window_should_close(self.window):
cur_time = glfw.get_time()
elapsed = cur_time - self.prev_time
self.prev_time = cur_time
glfw.poll_events()
self.impl.process_inputs()
self._process(elapsed)
imgui.new_frame()
imgui.set_next_window_position(0, 0)
imgui.set_next_window_size(280, 180)
imgui.begin("Uniforms", False, imgui.WINDOW_NO_RESIZE)
imgui.push_item_width(-45)
for cont in self.program.controls:
cont.update()
imgui.end()
glClear(GL_COLOR_BUFFER_BIT)
self._draw()
imgui.render()
self.impl.render(imgui.get_draw_data())
glfw.swap_buffers(self.window)
def _process(self, delta):
self.u_mpos += self.mvel * delta
self.uniHolder.mousePos.set_update(self.u_mpos)
self.uniHolder.zoom.value += self.zm_vel * delta
self.uniHolder.zoom.update()
x = pow(0.002, delta)
self.mvel *= x
self.zm_vel *= x
def render_snippet(
source,
file_path,
title="",
width=200,
height=200,
auto_layout=False,
output_dir='.',
click=None,
):
_patch_imgui()
source = find_fonts(source)
init_source, frame_source = split_sources(source)
init_code = compile(init_source, '<str>', 'exec')
frame_code = compile(frame_source, '<str>', 'exec')
window_name = "minimal ImGui/GLFW3 example"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# OS X supports only forward-compatible core profiles from 3.2
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# note: creating context without window is tricky so made window invisible
glfw.window_hint(glfw.VISIBLE, False)
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
impl = GlfwRenderer(window)
exec_ns = _ns(globals(), locals())
if init_source:
exec(init_code, exec_ns)
glfw.poll_events()
# render target for framebuffer
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
# create new framebuffer
offscreen_fb = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
# attach texture to framebuffer
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, texture, 0)
# note: Clicking simulation is hacky as f**k and it
# requires at least three frames to be rendered:
# * 1st with mouse in position but without button pressed.
# * 2nd in roughly same posiotion of mouse to turn on hover
# mouse button starts to press but still does not trigger click.
# * 3rd in the same position with button pressed still to finally
# trigger the "clicked" state.
# note: If clicking simulation is not required we draw only one frame.
for m_state in ([None, None, None] if not click else [False, True, True]):
# note: Mouse click MUST be simulated before new_frame call!
if click:
impl.io.mouse_draw_cursor = True
simulate_click(click[0], click[1], m_state)
else:
# just make sure mouse state is clear
_clear_mouse()
impl.process_inputs()
imgui.new_frame()
with imgui.styled(imgui.STYLE_ALPHA, 1):
imgui.core.set_next_window_size(0, 0)
if auto_layout:
imgui.set_next_window_size(width - 10, height - 10)
imgui.set_next_window_position(impl.io.display_size.x * 0.5,
impl.io.display_size.y * 0.5,
pivot_x=0.5,
pivot_y=0.5)
exec(frame_code, exec_ns)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
gl.glClearColor(1, 1, 1, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
# retrieve pixels from framebuffer and write to file
pixels = gl.glReadPixels(0, 0, width, height, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE)
image = Image.frombytes('RGBA', (width, height), pixels)
# note: glReadPixels returns lines "bottom to top" but PIL reads bytes
# top to bottom
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save(os.path.join(output_dir, file_path))
glfw.terminate()
class Application(object):
def __init__(self):
self.camera = TrackballCamera(radius=5.0)
def init(self, viewer):
self.viewer = viewer
window = Window(width=1200, height=675, name='contact modes')
window.set_on_init(self.init_win)
window.set_on_draw(self.render)
window.set_on_key_press(self.on_key_press)
window.set_on_key_release(self.on_key_release)
window.set_on_mouse_press(self.on_mouse_press)
window.set_on_mouse_drag(self.on_mouse_drag)
window.set_on_resize(self.on_resize)
viewer.add_window(window)
self.window = window
self.imgui_impl = GlfwRenderer(window.window, False)
def init_win(self):
glEnable(GL_LIGHTING)
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHT0)
# glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
# Enable anti-aliasing and circular points.
glEnable(GL_LINE_SMOOTH)
glEnable(GL_POINT_SMOOTH)
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
#
self.grid = Grid(0.25, 5)
self.grid.get_tf_world().set_translation(np.array([0, 0, -0.5]))
def render(self):
# Clear frame.
glClearColor(0.2, 0.3, 0.3, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Draw.
# self.draw_grid()
# Menu.
self.imgui_impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Cmd+Q', False, True)
if clicked_quit:
exit(1)
imgui.end_menu()
imgui.end_main_menu_bar()
imgui.render()
self.imgui_impl.render(imgui.get_draw_data())
def draw_grid(self, shader):
self.grid.draw(shader)
def on_resize(self, width, height):
glViewport(0, 0, width, height)
def on_key_press(self, win, key, scancode, action, mods):
pass
def on_key_release(self, win, key, scancode, action, mods):
pass
def on_mouse_press(self, x, y, button, modifiers):
if imgui.get_io().want_capture_mouse:
return
x = 2.0 * (x / self.window.width) - 1.0
y = 2.0 * (y / self.window.height) - 1.0
if button == 1: # left click
self.camera.mouse_roll(x, y, False)
if button == 4: # right click
self.camera.mouse_zoom(x, y, False)
def on_mouse_drag(self, x, y, dx, dy, button, modifiers):
if imgui.get_io().want_capture_mouse:
return
x = 2.0 * (x / self.window.width) - 1.0
y = 2.0 * (y / self.window.height) - 1.0
if button == 1: # left click
self.camera.mouse_roll(x, y)
if button == 4: # right click
self.camera.mouse_zoom(x, y)
class MainWindow():
def __init__(self, gui=True, pipe=None, img=None):
self.use_imgui = gui
self.use_occt = not gui
self.please_stop = False
self.rqq = rqQueue()
self.texture_updated = False
self.prev_pos = [0, 0]
self.offscreen_view_size = [0, 0]
if self.use_imgui:
print("Creating IMGUI context")
imgui.create_context()
else:
print("IMGUI disabled")
# Create a windowed mode window and its OpenGL context
if self.use_imgui:
self.canva = glfwViewer3d()
self.canva.set_pipe(pipe)
self.canva.set_img(img)
self.canva.init_driver()
self.impl = GlfwRenderer(self.canva.window)
else:
self.canva = offscreenViewer3d()
self.canva.set_pipe(pipe)
self.canva.set_img(img)
def parse_reply(self):
rp = self.canva.pipe.recv()
jdata = json.loads(rp)
if jdata['rp'] == replies[RP_IMAGE_DATA]:
if (self.offscreen_view_size[0] == self.canva.view_size[0]) and (
self.offscreen_view_size[1] == self.canva.view_size[1]):
self.canva.set_image(self.canva.view_size[0],
self.canva.view_size[1],
data=self.canva.img.buf)
else:
self.canva.set_image_black()
self.canva.reply_received()
elif jdata['rp'] == replies[RP_ACK]:
if (self.offscreen_view_size[0] == self.canva.view_size[0]) and (
self.offscreen_view_size[1] == self.canva.view_size[1]):
self.canva.set_image(self.canva.view_size[0],
self.canva.view_size[1],
data=self.canva.img.buf)
else:
self.canva.set_image_black()
self.canva.reply_received()
elif jdata['rp'] == replies[RP_ACK_SET_SIZE]:
self.offscreen_view_size = [jdata['args'][0], jdata['args'][1]]
if (self.offscreen_view_size[0] == self.canva.view_size[0]) and (
self.offscreen_view_size[1] == self.canva.view_size[1]):
self.canva.set_image(self.canva.view_size[0],
self.canva.view_size[1],
data=self.canva.img.buf)
else:
self.canva.set_image_black()
self.canva.reply_received()
def mainloop(self):
if self.use_imgui:
self.canva.init_shader()
self.canva.create_objects()
self.rqq.rq_set_size(self.canva.view_size[0],
self.canva.view_size[1])
print("Waiting set size reply")
self.rqq.process(self.canva)
self.parse_reply()
self.rqq.rq_load_image()
while (not self.canva.should_close() and (not self.please_stop)):
self.canva.proc()
if self.canva.get_need_resize():
self.canva.set_image_black()
self.rqq.rq_set_size(self.canva.view_size[0],
self.canva.view_size[1])
self.canva.start_frame()
self.canva.swap_buffers()
self.canva.poll_events()
continue
self.rqq.process(self.canva)
if self.canva.pipe.poll() == True:
self.parse_reply()
self.impl.process_inputs()
imgui.new_frame()
if imgui.begin_main_menu_bar():
if imgui.begin_menu("File", True):
clicked_quit, selected_quit = imgui.menu_item(
"Quit", 'Ctrl+Q', False, True)
if clicked_quit:
self.please_stop = True
imgui.end_menu()
if imgui.begin_menu("Render", True):
imgui.menu_item("Save", None, False, True)
imgui.end_menu()
imgui.end_main_menu_bar()
# right button rotation
if imgui.is_mouse_down(1):
if self.canva.drag_start == None:
pos = imgui.get_io().mouse_pos
self.canva.drag_start = [pos[0], pos[1]]
self.rqq.rq_start_rotation(self.canva.drag_start[0],
self.canva.drag_start[1])
else:
pos = imgui.get_io().mouse_pos
self.pt = [pos[0], pos[1]]
self.rqq.rq_rotate(self.pt[0], self.pt[1])
# left button panning
elif imgui.is_mouse_down(0):
if self.canva.drag_start == None:
pos = imgui.get_io().mouse_pos
self.canva.drag_start = [pos[0], pos[1]]
self.prev_pos = pos
else:
pos = imgui.get_io().mouse_pos
if not self.prev_pos == pos:
self.rqq.rq_pan(pos[0] - self.prev_pos[0],
pos[1] - self.prev_pos[1])
self.prev_pos = pos
# wheel button scrolling
else:
self.canva.drag_start = None
mw = imgui.get_io().mouse_wheel
pos = imgui.get_io().mouse_pos
if mw != 0:
self.rqq.rq_scroll(mw)
else:
if not self.prev_pos == pos:
self.rqq.rq_move(pos[0], pos[1])
self.prev_pos = pos
self.canva.start_frame()
imgui.render()
draw_data = imgui.get_draw_data()
self.impl.render(draw_data)
self.canva.swap_buffers()
self.canva.poll_events()
self.canva.rq_stop()
self.canva.pipe.close()
print("GUI stopped")
else:
while True:
rq = self.canva.pipe.recv()
jdata = json.loads(rq)
#print("rq:", rq, "jdata:", type(jdata))
if jdata['rq'] == requests[RQ_LOAD_IMAGE]:
tex = self.canva.call_load_image()
elif jdata['rq'] == requests[RQ_START_ROTATION]:
self.canva.call_start_rotation(jdata['args'][0],
jdata['args'][1])
elif jdata['rq'] == requests[RQ_ROTATE]:
self.canva.call_rotate(jdata['args'][0], jdata['args'][1])
elif jdata['rq'] == requests[RQ_SET_SIZE]:
self.canva.call_set_size(jdata['args'][0],
jdata['args'][1])
elif jdata['rq'] == requests[RQ_SCROLL]:
self.canva.call_scroll(jdata['args'])
elif jdata['rq'] == requests[RQ_MOVE]:
self.canva.call_move(jdata['args'][0], jdata['args'][1])
elif jdata['rq'] == requests[RQ_PAN]:
self.canva.call_pan(jdata['args'][0], jdata['args'][1])
elif jdata['rq'] == requests[RQ_STOP]:
break
self.canva.img.unlink()
self.canva.pipe.close()
print("OCCT stopped")
class Window:
def __init__(self):
if not glfw.init():
raise RuntimeError("Unable to initialize glfw.")
w_window, h_window = 800, 600
self.window = glfw.create_window(w_window, h_window,
"Voxel Visualizer", None, None)
if not self.window:
glfw.terminate()
raise RuntimeError("Unable to create window.")
monitor = glfw.get_primary_monitor()
mode = glfw.get_video_mode(monitor)
w_mon, h_mon = mode.size
# center window.
glfw.set_window_pos(self.window, int(0.5 * w_mon - 0.5 * w_window),
int(0.5 * h_mon - 0.5 * h_window))
# Make the window's context current
glfw.make_context_current(self.window)
glfw.set_framebuffer_size_callback(self.window, self.on_resize)
# add mouse handlers.
glfw.set_input_mode(self.window, glfw.STICKY_MOUSE_BUTTONS, glfw.TRUE)
glfw.set_mouse_button_callback(self.window, self.on_mouse_btn)
glfw.set_cursor_pos_callback(self.window, self.on_mouse_move)
glfw.set_window_size_callback(self.window, self.on_resize)
glfw.set_key_callback(self.window, self.keyboard_callback)
glfw.set_char_callback(self.window, self.char_callback)
glfw.set_scroll_callback(self.window, self.scroll_callback)
self.voxel_dims = glow.ivec3(256, 256, 32)
# read config file.
CFG = yaml.safe_load(open("config/semantic-kitti.yaml", 'r'))
color_dict = CFG["color_map"]
self.label_colors = glow.GlTextureRectangle(1024,
1,
internalFormat=GL_RGB,
format=GL_RGB)
cols = np.zeros((1024 * 3), dtype=np.uint8)
for label_id, color in color_dict.items():
cols[3 * label_id + 0] = color[2]
cols[3 * label_id + 1] = color[1]
cols[3 * label_id + 2] = color[0]
self.label_colors.assign(cols)
self.initializeGL()
# initialize imgui
imgui.create_context()
self.impl = GlfwRenderer(self.window, attach_callbacks=False)
self.on_resize(self.window, w_window, h_window)
self.data = []
self.isDrag = False
self.buttonPressed = None
self.cam = Camera()
self.cam.lookAt(25.0, 25.0, 25.0, 0.0, 0.0, 0.0)
self.currentTimestep = 0
self.sliderValue = 0
self.showLabels = True
def initializeGL(self):
""" initialize GL related stuff. """
self.num_instances = np.prod(self.voxel_dims)
# see https://stackoverflow.com/questions/28375338/cube-using-single-gl-triangle-strip, but the normals are a problem.
# verts = np.array([
# -1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1,
# -1, 1, -1, -1, -1, 1, -1, 1, 1, -1
# ],
# dtype=np.float32)
# yapf: disable
p1 = [1, 0, 0]
p2 = [0, 0, 0]
p3 = [1, 1, 0]
p4 = [0, 1, 0]
p5 = [1, 0, 1]
p6 = [0, 0, 1]
p7 = [0, 1, 1]
p8 = [1, 1, 1]
verts = np.array([
# first face
p4, p3, p7, p3, p7, p8,
# second face
p7, p8, p5, p7, p6, p5,
# third face
p8, p5, p3, p5, p3, p1,
# fourth face
p3, p1, p4, p1, p4, p2,
# fifth face
p4, p2, p7, p2, p7, p6,
# sixth face
p6, p5, p2, p5, p2, p1
], dtype=np.float32).reshape(-1)
normals = np.array([[0, 1, 0] * 6,
[0, 0, 1] * 6,
[1, 0, 0] * 6,
[0, 0, -1] * 6,
[-1, 0, 0] * 6,
[0, -1, 0] * 6
], dtype=np.float32).reshape(-1)
# yapf: enable
glow.WARN_INVALID_UNIFORMS = True
self.labels = np.array([], dtype=np.float32)
self.cube_verts = glow.GlBuffer()
self.cube_verts.assign(verts)
self.cube_normals = glow.GlBuffer()
self.cube_normals.assign(normals)
self.label_vbo = glow.GlBuffer()
glPointSize(5.0)
self.vao = glGenVertexArrays(1)
glBindVertexArray(self.vao)
SIZEOF_FLOAT = 4
self.cube_verts.bind()
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * SIZEOF_FLOAT,
GLvoidp(0))
glEnableVertexAttribArray(0)
self.cube_verts.release()
self.cube_normals.bind()
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * SIZEOF_FLOAT,
GLvoidp(0))
glEnableVertexAttribArray(1)
self.cube_normals.release()
glEnableVertexAttribArray(2)
self.label_vbo.bind()
# Note: GL_UNSINGED_INT did not work as expected! I could not figure out what was wrong there!
glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, SIZEOF_FLOAT,
GLvoidp(0))
self.label_vbo.release()
glVertexAttribDivisor(2, 1)
glBindVertexArray(0)
self.program = glow.GlProgram()
self.program.attach(
glow.GlShader.fromFile(GL_VERTEX_SHADER,
"auxiliary/shaders/draw_voxels.vert"))
self.program.attach(
glow.GlShader.fromFile(GL_FRAGMENT_SHADER,
"auxiliary/shaders/draw_voxels.frag"))
self.program.link()
self.prgDrawPose = glow.GlProgram()
self.prgDrawPose.attach(
glow.GlShader.fromFile(GL_VERTEX_SHADER,
"auxiliary/shaders/empty.vert"))
self.prgDrawPose.attach(
glow.GlShader.fromFile(GL_GEOMETRY_SHADER,
"auxiliary/shaders/draw_pose.geom"))
self.prgDrawPose.attach(
glow.GlShader.fromFile(GL_FRAGMENT_SHADER,
"auxiliary/shaders/passthrough.frag"))
self.prgDrawPose.link()
self.prgTestUniform = glow.GlProgram()
self.prgTestUniform.attach(
glow.GlShader.fromFile(GL_VERTEX_SHADER,
"auxiliary/shaders/check_uniforms.vert"))
self.prgTestUniform.attach(
glow.GlShader.fromFile(GL_FRAGMENT_SHADER,
"auxiliary/shaders/passthrough.frag"))
self.prgTestUniform.link()
# general parameters
glClearColor(1.0, 1.0, 1.0, 1.0)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
glEnable(GL_LINE_SMOOTH)
# x = forward, y = left, z = up to x = right, y = up, z = backward
self.conversion_ = np.array(
[0, -1, 0, 0, 0, 0, 1, 0, -1, 0, 0, 0, 0, 0, 0, 1],
dtype=np.float32).reshape(4, 4)
self.program.bind()
self.program["voxel_size"] = 0.5
self.program["voxel_dims"] = self.voxel_dims
self.program["label_colors"] = 0
self.program.release()
self.vao_no_points = glGenVertexArrays(1)
def open_directory(self, directory):
""" open given sequences directory and get filenames of relevant files. """
self.subdirs = [
subdir for subdir in ["voxels", "predictions"]
if os.path.exists(os.path.join(directory, subdir))
]
if len(self.subdirs) == 0:
raise RuntimeError("Neither 'voxels' nor 'predictions' found in " +
directory)
self.availableData = {}
self.data = {}
for subdir in self.subdirs:
self.availableData[subdir] = []
self.data[subdir] = {}
complete_path = os.path.join(directory, subdir)
files = os.listdir(complete_path)
data = sorted([
os.path.join(complete_path, f) for f in files
if f.endswith(".bin")
])
if len(data) > 0:
self.availableData[subdir].append("input")
self.data[subdir]["input"] = data
self.num_scans = len(data)
data = sorted([
os.path.join(complete_path, f) for f in files
if f.endswith(".label")
])
if len(data) > 0:
self.availableData[subdir].append("labels")
self.data[subdir]["labels"] = data
self.num_scans = len(data)
data = sorted([
os.path.join(complete_path, f) for f in files
if f.endswith(".invalid")
])
if len(data) > 0:
self.availableData[subdir].append("invalid")
self.data[subdir]["invalid"] = data
self.num_scans = len(data)
data = sorted([
os.path.join(complete_path, f) for f in files
if f.endswith(".occluded")
])
if len(data) > 0:
self.availableData[subdir].append("occluded")
self.data[subdir]["occluded"] = data
self.num_scans = len(data)
self.current_subdir = 0
self.current_data = self.availableData[self.subdirs[
self.current_subdir]][0]
self.currentTimestep = 0
self.sliderValue = 0
self.lastChange = None
self.lastUpdate = time.time()
self.button_backward_hold = False
self.button_forward_hold = False
# todo: modify based on available stuff.
self.showLabels = (self.current_data == "labels")
self.showInput = (self.current_data == "input")
self.showInvalid = (self.current_data == "invalid")
self.showOccluded = (self.current_data == "occludded")
def setCurrentBufferData(self, data_name, t):
# update buffer content with given data identified by data_name.
subdir = self.subdirs[self.current_subdir]
if len(self.data[subdir][data_name]) < t: return False
# Note: uint with np.uint32 did not work as expected! (with instances and uint32 this causes problems!)
if data_name == "labels":
buffer_data = np.fromfile(self.data[subdir][data_name][t],
dtype=np.uint16).astype(np.float32)
else:
buffer_data = unpack(
np.fromfile(self.data[subdir][data_name][t],
dtype=np.uint8)).astype(np.float32)
self.label_vbo.assign(buffer_data)
return True
def on_resize(self, window, w, h):
# set projection matrix
fov = math.radians(45.0)
aspect = w / h
self.projection_ = glPerspective(fov, aspect, 0.1, 2000.0)
self.impl.resize_callback(window, w, h)
def on_mouse_btn(self, window, button, action, mods):
x, y = glfw.get_cursor_pos(self.window)
imgui.get_io().mouse_pos = (x, y)
if imgui.get_io().want_capture_mouse:
return
if action == glfw.PRESS:
self.buttonPressed = button
self.isDrag = True
self.cam.mousePressed(x, y, self.buttonPressed, None)
else:
self.buttonPressed = None
self.isDrag = False
self.cam.mouseReleased(x, y, self.buttonPressed, None)
def on_mouse_move(self, window, x, y):
if self.isDrag:
self.cam.mouseMoved(x, y, self.buttonPressed, None)
def keyboard_callback(self, window, key, scancode, action, mods):
self.impl.keyboard_callback(window, key, scancode, action, mods)
if not imgui.get_io().want_capture_keyboard:
if key == glfw.KEY_B or key == glfw.KEY_LEFT:
self.currentTimestep = self.sliderValue = max(
0, self.currentTimestep - 1)
if key == glfw.KEY_N or key == glfw.KEY_RIGHT:
self.currentTimestep = self.sliderValue = min(
self.num_scans - 1, self.currentTimestep + 1)
if key == glfw.KEY_Q or key == glfw.KEY_ESCAPE:
exit(0)
def char_callback(self, window, char):
self.impl.char_callback(window, char)
def scroll_callback(self, window, x_offset, y_offset):
self.impl.scroll_callback(window, x_offset, y_offset)
def run(self):
# Loop until the user closes the window
while not glfw.window_should_close(self.window):
# Poll for and process events
glfw.poll_events()
# build gui.
self.impl.process_inputs()
w, h = glfw.get_window_size(self.window)
glViewport(0, 0, w, h)
imgui.new_frame()
timeline_height = 35
imgui.push_style_var(imgui.STYLE_WINDOW_ROUNDING, 0)
imgui.push_style_var(imgui.STYLE_FRAME_ROUNDING, 0)
imgui.set_next_window_position(0, h - timeline_height - 10)
imgui.set_next_window_size(w, timeline_height)
imgui.begin(
"Timeline", False, imgui.WINDOW_NO_TITLE_BAR
| imgui.WINDOW_NO_RESIZE | imgui.WINDOW_NO_SCROLLBAR)
imgui.columns(1)
imgui.same_line(0, 0)
imgui.push_item_width(-50)
changed, value = imgui.slider_int("", self.sliderValue, 0,
self.num_scans - 1)
if changed: self.sliderValue = value
if self.sliderValue != self.currentTimestep:
self.currentTimestep = self.sliderValue
imgui.push_style_var(imgui.STYLE_FRAME_ROUNDING, 3)
play_delay = 1
refresh_rate = 0.05
current_time = time.time()
imgui.same_line(spacing=5)
changed = imgui.button("<", 20)
if self.currentTimestep > 0:
# just a click
if changed:
self.currentTimestep = self.sliderValue = self.currentTimestep - 1
self.lastUpdate = current_time
# button pressed.
if imgui.is_item_active() and not self.button_backward_hold:
self.hold_start = current_time
self.button_backward_hold = True
if not imgui.is_item_active() and self.button_backward_hold:
self.button_backward_hold = False
# start playback when button pressed long enough
if self.button_backward_hold and (
(current_time - self.hold_start) > play_delay):
if (current_time - self.lastUpdate) > refresh_rate:
self.currentTimestep = self.sliderValue = self.currentTimestep - 1
self.lastUpdate = current_time
imgui.same_line(spacing=2)
changed = imgui.button(">", 20)
if self.currentTimestep < self.num_scans - 1:
# just a click
if changed:
self.currentTimestep = self.sliderValue = self.currentTimestep + 1
self.lastUpdate = current_time
# button pressed.
if imgui.is_item_active() and not self.button_forward_hold:
self.hold_start = current_time
self.button_forward_hold = True
if not imgui.is_item_active() and self.button_forward_hold:
self.button_forward_hold = False
# start playback when button pressed long enough
if self.button_forward_hold and (
(current_time - self.hold_start) > play_delay):
if (current_time - self.lastUpdate) > refresh_rate:
self.currentTimestep = self.sliderValue = self.currentTimestep + 1
self.lastUpdate = current_time
imgui.pop_style_var(3)
imgui.end()
imgui.set_next_window_position(20, 20, imgui.FIRST_USE_EVER)
imgui.set_next_window_size(200, 150, imgui.FIRST_USE_EVER)
imgui.begin("Show Data")
if len(self.subdirs) > 1:
for i, subdir in enumerate(self.subdirs):
changed, value = imgui.checkbox(subdir,
self.current_subdir == i)
if i < len(self.subdirs) - 1: imgui.same_line()
if changed and value: self.current_subdir = i
subdir = self.subdirs[self.current_subdir]
data_available = "input" in self.availableData[subdir]
if data_available:
imgui.push_style_var(imgui.STYLE_ALPHA, 1.0)
else:
imgui.push_style_var(imgui.STYLE_ALPHA, 0.3)
changed, value = imgui.checkbox("input", self.showInput)
if changed and value and data_available:
self.showInput = True
self.showLabels = False
imgui.pop_style_var()
data_available = "labels" in self.availableData[subdir]
if data_available:
imgui.push_style_var(imgui.STYLE_ALPHA, 1.0)
else:
imgui.push_style_var(imgui.STYLE_ALPHA, 0.3)
changed, value = imgui.checkbox("labels", self.showLabels)
if changed and value and data_available:
self.showInput = False
self.showLabels = True
imgui.pop_style_var()
data_available = "invalid" in self.availableData[subdir]
if data_available:
imgui.push_style_var(imgui.STYLE_ALPHA, 1.0)
else:
imgui.push_style_var(imgui.STYLE_ALPHA, 0.3)
changed, value = imgui.checkbox("invalid", self.showInvalid)
if changed and data_available: self.showInvalid = value
imgui.pop_style_var()
data_available = "occluded" in self.availableData[subdir]
if data_available:
imgui.push_style_var(imgui.STYLE_ALPHA, 1.0)
else:
imgui.push_style_var(imgui.STYLE_ALPHA, 0.3)
changed, value = imgui.checkbox("occluded", self.showOccluded)
if changed and data_available: self.showOccluded = value
imgui.pop_style_var()
imgui.end()
# imgui.show_demo_window()
showData = []
if self.showInput: showData.append("input")
if self.showOccluded: showData.append("occluded")
if self.showInvalid: showData.append("invalid")
mvp = self.projection_ @ self.cam.matrix @ self.conversion_
glClearColor(1.0, 1.0, 1.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glBindVertexArray(self.vao)
self.program.bind()
self.program["mvp"] = mvp.transpose()
self.program["view_mat"] = (
self.cam.matrix @ self.conversion_).transpose()
self.program["lightPos"] = glow.vec3(10, 10, 10)
self.program["voxel_scale"] = 0.8
self.program["voxel_alpha"] = 1.0
self.program["use_label_colors"] = True
self.label_colors.bind(0)
if self.showLabels:
self.setCurrentBufferData("labels", self.currentTimestep)
glDrawArraysInstanced(GL_TRIANGLES, 0, 36, self.num_instances)
self.program["use_label_colors"] = False
self.program["voxel_color"] = glow.vec3(0.3, 0.3, 0.3)
self.program["voxel_alpha"] = 0.5
for data_name in showData:
self.program["voxel_scale"] = 0.5
if data_name == "input": self.program["voxel_scale"] = 0.8
self.setCurrentBufferData(data_name, self.currentTimestep)
glDrawArraysInstanced(GL_TRIANGLES, 0, 36, self.num_instances)
self.program.release()
self.label_colors.release(0)
glBindVertexArray(self.vao_no_points)
self.prgDrawPose.bind()
self.prgDrawPose["mvp"] = mvp.transpose()
self.prgDrawPose["pose"] = np.identity(4, dtype=np.float32)
self.prgDrawPose["size"] = 1.0
glDrawArrays(GL_POINTS, 0, 1)
self.prgDrawPose.release()
glBindVertexArray(0)
# draw gui ontop.
imgui.render()
self.impl.render(imgui.get_draw_data())
# Swap front and back buffers
glfw.swap_buffers(self.window)