Best way to render pixels to the screen in python?

Question

I'm writing an interactive (zoom/pan) mandelbrot set viewer in python, and I'm having some performance issues. I'm currently using pyglet and PyOpenGL to render the pixels since I like how it handles mouse events. I generate the pixel values using numpy, and after some searching on stack exchange/docs/other places, I'm currently using glDrawPixels to draw the pixels. The application is horribly slow, taking ~1.5s to draw. I've heard that using textures is much faster, but I have no experience with them, and learning that much OpenGL seems like it should be unnecessary. Another approach I have considered is using vertex lists and batched rendering with pyglet, but it seems wrong to created a new GL_POINT at every single pixel on the screen. Am I going about this all wrong? Is there a better way to render something to the screen when pixels change so frequently? Code below:

# this code all is in a class that subclasses pyglet.window.Window
# called every 1/10.0 seconds, update 10 frames
def update_region(self):
    # this code just computes new mandelbrot detail
    if self.i < self.NUM_IT:
        for _ in range(10): # do 10 iterations every update, can be customizable
            self.z = np.where(np.absolute(self.z) < self.THRESHOLD,
                       self.z ** 2 + self.reg, self.z)
            self.pixels = np.where(
                            (self.pixels == self.NUM_IT) & (np.absolute(self.z) > 
                             self.THRESHOLD), self.i, self.pixels)
            self.i = self.i + 1


def update_frame(self, x, y):
    self.update_region()
    # color_pixels is what will actually be rendered
    self.color_pixels = self.cmap.to_rgba(self.pixels).flatten()


def on_draw(self): # draw method called every update (set to .1s)
    
        start = time.time()
        glClear(GL_COLOR_BUFFER_BIT)
        glDrawPixels(2 * self.W, 2 * self.H, GL_RGBA, GL_FLOAT, (GLfloat * len(self.color_pixels))(*self.color_pixels))
        glutSwapBuffers()
        print('on_draw took {0} seconds'.format(time.time() - start))

Answer 1

Are you sure it's the glDrawPixels slowing you down? In your code for update_frame there's a cmap.to_rgba() which I assume is mapping the single value calculated by Mandelbrot into an RGB triple, and then whatever .flatten() does. Copying the entire image, twice, won't help.

For drawing raster images that don't need 3D scaling, pyglet has the image module and .blit()

You are right that a vertex list of points would not help.

Loading the image into a texture would be a bit more OpenGL code, but not too much. You could then zoom in OpenGL, and do the Mandelbrot -> RGB conversion on the GPU as it is drawn in a fragment shader.