Draw to an FBO and render to imgui window?

[egradman]

I've been using pyimgui for years for robotics and computer vision, and this bundle makes things SO MUCH EASIER! Thank you.

I'm trying to draw to an FBO bound to a texture, and draw that texture to the background of my window (in python). I'm getting an OpenGL error when drawing to the FBO. StackOverflow suggests this may be because I don't have a valid glfw context while rendering my gui, but that doesn't sound right to me. I'm sure this isn't a problem with imgui_bundle, but I'm posting here in hopes that you can point me in the right direction.

  File "/Users/egradman/dev/tftest/minimal.py", line 34, in draw_background
    glMatrixMode(GL_PROJECTION)
  File "/Users/egradman/micromamba/envs/ros_env/lib/python3.10/site-packages/OpenGL/platform/baseplatform.py", line 415, in __call__
    return self( *args, **named )
  File "/Users/egradman/micromamba/envs/ros_env/lib/python3.10/site-packages/OpenGL/error.py", line 230, in glCheckError
    raise self._errorClass(
OpenGL.error.GLError: GLError(
        err = 1282,
        description = b'invalid operation',
        baseOperation = glMatrixMode,
        cArguments = (GL_PROJECTION,)

This is the minimal code:

from imgui_bundle import imgui, hello_imgui
import glfw
from OpenGL.GL import *

class Minimal:
    def __init__(self):
        self.radius = 10

    def step(self):
        changed, self.radius = imgui.slider_float("radius", self.radius,
            v_min=0.0, v_max=1080.0
            format="%.0f"
        )

        self.draw_background()
        imgui.image(self.texture, size=imgui.ImVec2(1920, 1080))

    def generate_background(self):
        self.fbo = glGenFramebuffers(1)
        glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
        self.texture = glGenTextures(1)

        glBindTexture(GL_TEXTURE_2D, self.texture)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1920, 1080, 0, GL_RGB, GL_UNSIGNED_BYTE, None)
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self.texture, 0)
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

    def draw_background(self):
        glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
        glViewport(0, 0, 1920, 1080)
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        glOrtho(0, 1920, 0, 1080, -1, 1)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        glTranslatef(1920 / 2, 1080 / 2, 0)
        glColor3f(1.0, 0.0, 0.0)  # Red circle
        glVertex2f(0,0)
        glVertex(self.radius, self.radius)
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

def main(args=None):
    if not glfw.init():
        return
    minimal = Minimal()

    runner_params = hello_imgui.RunnerParams()
    runner_params.backend_type = hello_imgui.BackendType.glfw
    runner_params.callbacks.post_init = minimal.generate_background
    runner_params.app_window_params.window_title = "testing"
    runner_params.app_window_params.window_geometry.full_screen_mode = \
        hello_imgui.FullScreenMode(hello_imgui.FullScreenMode.full_screen_desktop_resolution)
    runner_params.fps_idling = hello_imgui.FpsIdling(enable_idling=False)
    runner_params.callbacks.show_gui = minimal.step
    hello_imgui.run(runner_params)

if __name__ == '__main__':
    main()

[pthom]

I've been using pyimgui for years for robotics and computer vision, and this bundle makes things SO MUCH EASIER! Thank you.

Thanks, that was the intent :-)

I'm trying to draw to an FBO bound to a texture, and draw that texture to the background of my window (in python). I'm getting an OpenGL error when drawing to the FBO.

I am not an OpenGL specialist, but it seems like the function calls which fails are deprecated in OpenGL3.2 / Core profile.
For example, glMatrixMode is a fixed-function pipeline command, which is deprecated in the core profile context for OpenGL 3.2. HelloImGui and ImGui Bundle are using OpenGL 3.2 in core profile mode.

More details here : those are advices by Chat GPT, on how to transform your fixed-function pipeline code into code that uses shaders

[egradman]

Yep! I think you and ChatGPT are entirely correct. I've been out of the OpenGL game for a long time.

What I really need is a way to draw to imgui's opengl context using a higher-level graphics API.

• I could use SDL2_gfx (but that isn't compiled in to the SDL2 library in imgui_bundle?)
• I could use pyglet (great API!) (but that would require creating the window with pyglet, I think. I could do this, but then I wouldn't be using hello_imgui, correct?)
• Any other suggestions?

[pthom]

Ok, I understand your need.

• SDL2_gfx is not compiled in imgui bundle.
• pyglet is not compatible with hello imgui
• Any other suggestions?

If your intent is to draw in a CPU image (i.e. for example a numpy array), you can use

• skimage.draw
• or the OpenCv drawing primitives

If your intent is to draw using GPU calls, you could use ImGui's API.

The code below tries to demonstrate several approaches:

from imgui_bundle import imgui, hello_imgui, ImVec2
import glfw
import numpy as np
from OpenGL import GL
import cv2


def draw_circle(radius, center, image_size, circle_color, background_color):
    """Method 1: Draw a circle using numpy + basic math and returns a CPU image (under the form of a numpy array)
    Note: this creates and returns a CPU image (not a GPU texture).
    Ideally this should receive and modify a CPU image.
    """
    image = np.full((image_size[1], image_size[0], 3), background_color, dtype=np.uint8)
    y_indices, x_indices = np.indices((image_size[1], image_size[0]))
    circle_mask = (x_indices - center[0])**2 + (y_indices - center[1])**2 <= radius**2
    image[circle_mask] = circle_color
    return image


def create_texture(image):
    texture = GL.glGenTextures(1)
    GL.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1)
    GL.glBindTexture(GL.GL_TEXTURE_2D, texture)
    GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, image.shape[1], image.shape[0], 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, image)
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE)
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE)
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST)
    GL.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST)
    GL.glBindTexture(GL.GL_TEXTURE_2D, 0)

    return texture


def update_texture(texture, image):
    GL.glBindTexture(GL.GL_TEXTURE_2D, texture)
    GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, image.shape[1], image.shape[0], 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, image)
    GL.glBindTexture(GL.GL_TEXTURE_2D, 0)


class Minimal:
    def __init__(self):
        self.radius = 10
        self.image = draw_circle(self.radius, (1920 // 2, 1080 // 2), (1920, 1080), (255, 0, 0), (0, 0, 255))

    def generate_background(self):
        self.texture = create_texture(self.image)

    def step(self):
        changed, self.radius = imgui.slider_float("radius", self.radius,
                                                  v_min=0.0, v_max=1080.0,
                                                  format="%.0f"
                                                  )
        self.image = draw_circle(self.radius, (1920 // 2, 1080 // 2), (1920, 1080), (255, 0, 0), (0, 0, 255))

        # Method 2: draw a line in the CPU image using OpenCV2 drawing primitives
        cv2.line(self.image, (0, 0), (100, 100), (255, 0, 255), 4)

        update_texture(self.texture, self.image)
        imgui.image(self.texture, imgui.ImVec2(1920, 1080))

        # Method 3: Draw a circle using ImGui drawing primitives (this is *not* rendered in the CPU image self.image),
        # but will be rendered via GPU calls)
        imgui.get_foreground_draw_list().add_circle_filled(ImVec2(100, 100), 50, 0xff00ffff)


def main():
    minimal = Minimal()

    runner_params = hello_imgui.RunnerParams()
    runner_params.backend_type = hello_imgui.BackendType.glfw
    runner_params.callbacks.post_init = minimal.generate_background
    runner_params.app_window_params.window_title = "testing"
    # runner_params.app_window_params.window_geometry.full_screen_mode = \
    #     hello_imgui.FullScreenMode(hello_imgui.FullScreenMode.full_screen_desktop_resolution)
    runner_params.fps_idling = hello_imgui.FpsIdling(enable_idling=False)
    runner_params.callbacks.show_gui = minimal.step
    hello_imgui.run(runner_params)


if __name__ == '__main__':
    main()

[egradman]

Oh jeez, I'm embarrassed I didn't know those draw functions exist. That's exactly what I needed. Thank you so much.