求助：glReadPixels()读取Bresenham绘制的圆上点RGB始终返回(0,0,0)

Hey there! Let's troubleshoot why glReadPixels() keeps returning (0,0,0) even when you change your window background color or draw a Bresenham circle. This is a classic OpenGL pipeline issue—here are the most likely fixes to try:

1. You're Not Swapping/Flushing Buffers Correctly #

If your window uses double buffering (super common in GLUT with glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)), your drawing goes to an off-screen back buffer. If you call glReadPixels() before swapping buffers, you're reading the old front buffer (which is probably still black).

• Fix: Call glutSwapBuffers() after drawing to make your content visible, then read from the front buffer:

  // After drawing your circle
  glutSwapBuffers();
  glReadBuffer(GL_FRONT); // Explicitly target the front buffer
  glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixelData);
  

• If you're using single buffering, call glFlush() after drawing to ensure all rendering commands are executed before reading pixels.

2. Your Coordinate System Is Upside-Down #

OpenGL uses a window coordinate system where (0,0) is at the bottom-left corner, but many Bresenham implementations assume (0,0) is top-left (like most GUI systems). If you're passing unadjusted y-coordinates to glReadPixels(), you're reading the wrong pixel entirely.

• Fix: Invert the y-coordinate relative to your window height:

  int correctedY = windowHeight - y - 1; // y is your Bresenham y-value
  glReadPixels(x, correctedY, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixelData);
  

• Pro tip: Align your OpenGL projection with window pixels using gluOrtho2D(0, windowWidth, 0, windowHeight) so your Bresenham coordinates map directly to OpenGL's window space.

3. Your glReadPixels() Parameters Are Wrong #

Double-check that you're using the right format and type for RGB values. Mismatched parameters can lead to garbage data (like all zeros).

• Correct usage for RGB:

  unsigned char pixel[3]; // Holds R, G, B values (0-255)
  glReadPixels(x, y, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel);
  printf("RGB: (%d, %d, %d)\n", pixel[0], pixel[1], pixel[2]);
  

• If you're still having issues, adjust the pixel storage alignment (default is 4 bytes, which can cause padding for non-multiple-of-4 row lengths):

  glPixelStorei(GL_PACK_ALIGNMENT, 1); // Disable padding
  glReadPixels(...);
  

4. Your Drawing Pipeline Isn't Setting Colors/Clearing Buffers #

Even if you change the background color, if you don't clear the buffer with that color, OpenGL won't update it. Similarly, your Bresenham circle might not be drawing with the color you think.

• Fix: Always set and clear the background before drawing:

  glClearColor(0.5f, 0.5f, 0.5f, 1.0f); // Gray background
  glClear(GL_COLOR_BUFFER_BIT); // Clear the color buffer
  

• Make sure you set the circle color before drawing:

  glColor3f(1.0f, 0.0f, 0.0f); // Red circle
  drawBresenhamCircle(xc, yc, radius);
  

5. Test Isolated Cases to Narrow Down the Issue #

• First, try reading a pixel from the background (not the circle). If it still returns (0,0,0), the problem is definitely buffer swapping or coordinate inversion.
• If the background reads correctly, check that your Bresenham function is actually drawing pixels at the coordinates you're trying to read. Add debug prints to confirm the (x,y) values your function generates are within the window bounds.

Here's a quick corrected example snippet that ties all this together:

#include <GL/glut.h>
#include <stdio.h>

int windowWidth = 400;
int windowHeight = 400;

void drawBresenhamCircle(int xc, int yc, int r) {
    int x = 0, y = r;
    int d = 3 - 2*r;
    glBegin(GL_POINTS);
    while(x <= y) {
        glVertex2i(xc+x, yc+y);
        glVertex2i(xc+y, yc+x);
        glVertex2i(xc-y, yc+x);
        glVertex2i(xc-x, yc+y);
        glVertex2i(xc-x, yc-y);
        glVertex2i(xc-y, yc-x);
        glVertex2i(xc+y, yc-x);
        glVertex2i(xc+x, yc-y);
        d += (d < 0) ? (4*x +6) : (4*(x-y)+10);
        if(d >=0) y--;
        x++;
    }
    glEnd();
}

void display() {
    glClearColor(0.0f, 1.0f, 0.0f, 1.0f); // Green background
    glClear(GL_COLOR_BUFFER_BIT);
    
    glColor3f(1.0f, 0.0f, 0.0f); // Red circle
    drawBresenhamCircle(200, 200, 100);
    
    glutSwapBuffers(); // Swap to make content visible
    
    // Read the rightmost point of the circle (200+100, 200)
    unsigned char pixel[3];
    glReadBuffer(GL_FRONT);
    glReadPixels(300, 200, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel);
    
    printf("Pixel RGB: (%d, %d, %d)\n", pixel[0], pixel[1], pixel[2]);
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowSize(windowWidth, windowHeight);
    glutCreateWindow("Bresenham Circle Test");
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, windowWidth, 0, windowHeight); // Align coords to window
    glutDisplayFunc(display);
    glutMainLoop();
    return 0;
}

This should read (255, 0, 0) for the red circle pixel, or (0,255,0) if you read a background pixel.

内容的提问来源于stack exchange，提问作者Akash V