Python 使用glReadPixels从OpenGL获取颜色数据

我尝试在pyopengl中使用边界填充算法

但是，当我想得到三角形的颜色时，它不起作用

它只是得到背景色，而不是三角形的颜色

你可以在myDisplay（）函数中看到它。我已经用蓝色画了这个三角形

    glBegin(GL_LINE_LOOP)
    glVertex2i(100, 100)
    glVertex2i(150, 100)
    glVertex2i(150, 150)

但是我不知道它的颜色

    for i in range(120, 130):
        setPixel(i, 110)
        print(i, 110, getColor(i, 110))
        print(i, 110, getColor(i, 111))
        print(i, 110, getColor(i, 109))

同时，我画了一条线来测试，但我也不能确定它的颜色

    for i in range(120, 130):
        setPixel(i, 110)
        print(i, 110, getColor(i, 110))
        print(i, 110, getColor(i, 111))
        print(i, 110, getColor(i, 109))

这是getcolor的功能

def getColor(x, y):
    color = (GLuint * 1)(0)
    #读取点(x,y)的颜色color
    glReadPixels(122, 101, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, color)
    color=int(color[0])
    r = color & 255
    g = (color >> 8) & 255
    b = (color >> 16) & 255
    color = (r, g, b)
    return color

这是密码

# -*- coding:utf-8 -*-
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *


#判断c1,c2的颜色是否相同
def rgbColorEqual(c1, c2):
    # if (abs(c1[0]-c2[0]) < 0.001 and abs(c1[1], c2[1]) < 0.001 and abs(c1[2]-c2[2]) < 0.001):
    #     return 1
    # else:
    #     return 0
    return 1
#绘制像素点(x,y)
def setPixel(x, y):
    glBegin(GL_POINTS)
    glVertex2i(x, y)
    glEnd()
    glFlush()
    return
#获得点(x,y)的颜色
def getColor(x, y):
    color = (GLuint * 1)(0)
    #读取点(x,y)的颜色color
    glReadPixels(122, 101, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, color)
    color=int(color[0])
    r = color & 255
    g = (color >> 8) & 255
    b = (color >> 16) & 255
    color = (r, g, b)
    return color
#4-连通边界填充算法
def boundaryFill4(x, y, fillColor, borderColor):
    interiorColor=getColor(x,y)
    print(x,y,interiorColor)
    # if(not rgbColorEqual(interiorColor, borderColor) and not rgbColorEqual(interiorColor, fillColor)):
    #     setPixel(x, y)
    # boundaryFill4(x+1,y,fillColor,borderColor)
    # boundaryFill4(x-1,y,fillColor,borderColor)
    # boundaryFill4(x,y+1,fillColor,borderColor)
    # boundaryFill4(x,y-1,fillColor,borderColor)

#显示函数
def myDisplay():
    glClear(GL_COLOR_BUFFER_BIT)
    #设置填充色为a红色
    #设置边界色为b蓝色
    a = (1, 0, 0)
    b = (0, 0, 1)
    glColor3fv(b)
    #绘制三角形的边
    glBegin(GL_LINE_LOOP)
    glVertex2i(100, 100)
    glVertex2i(150, 100)
    glVertex2i(150, 150)
    glEnd()
    glFlush()
    #取图形中的一点，进行填充
    glColor3fv(a)
    for i in range(120, 130):
        setPixel(i, 110)
        print(i, 110, getColor(i, 110))
        print(i, 110, getColor(i, 111))
        print(i, 110, getColor(i, 109))
    for i in range(100,150):
        print(i,100,getColor(i,100))
    boundaryFill4(120, 106, a, b)


if __name__ == "__main__":
    glutInit()
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE)
    glutInitWindowPosition(100, 100)
    glutInitWindowSize(500, 500)
    glutCreateWindow('midpointcircle')
    glClearColor(0.5, 0.5, 0.5, 0)
    glMatrixMode(GL_PROJECTION)
    gluOrtho2D(0.0, 500.0, 0.0, 500.0)
    glutDisplayFunc(myDisplay)
    glutMainLoop()

#-*-编码：utf-8-*-
从OpenGL.GL导入*
从OpenGL.GLU导入*
从OpenGL.GLUT导入*
#判断c1，c2的颜色是否相同
def RGB颜色要求（c1、c2）：
#如果（abs（c1[0]-c2[0]）<0.001和abs（c1[1]，c2[1]）<0.001和abs（c1[2]-c2[2]）<0.001：
#返回1
#其他：
#返回0
返回1
#绘制像素点（x，y）
def设置像素（x，y）：
glBegin（GLU点）
glVertex2i（x，y）
格伦德（）
glFlush（）
返回
#获得点（x，y）的颜色
def getColor（x，y）：
颜色=（胶水*1）（0）
#读取点（x，y）的颜色颜色
glReadPixels（122、101、1、1、GL_RGB、GL_无符号字节、颜色）
颜色=int（颜色[0]）
r=255色
g=（颜色>>8）和255
b=（颜色>>16）和255
颜色=（r、g、b）
返回颜色
#4-连通边界填充算法
def boundaryFill4（x、y、fillColor、borderColor）：
interiorColor=getColor（x，y）
打印（x、y、内饰颜色）
#如果（非RGBColorQual（interiorColor，borderColor）和非RGBColorQual（interiorColor，fillColor））：
#设置像素（x，y）
#boundaryFill4（x+1，y，fillColor，borderColor）
#boundaryFill4（x-1，y，fillColor，borderColor）
#boundaryFill4（x，y+1，fillColor，borderColor）
#boundaryFill4（x，y-1，fillColor，borderColor）
#显示函数
def myDisplay（）：
glClear（GLU颜色缓冲位）
#设置填充色为A.红色
#设置边界色为B蓝色
a=（1,0,0）
b=（0,0,1）
GL3Fv（b）
#绘制三角形的边
glBegin（GL_线_环）
glVertex2i（100100）
glVertex2i（150100）
glVertex2i（150150）
格伦德（）
glFlush（）
#取图形中的一点，进行填充
GL3Fv（a）
对于范围内的i（120130）：
设置像素（i，110）
打印（i，110，getColor（i，110））
打印（i，110，getColor（i，111））
打印（i，110，getColor（i，109））
对于范围内的i（100150）：
打印（i，100，getColor（i，100））
边界填充4（120106，a，b）
如果名称=“\uuuuu main\uuuuuuuu”：
glutInit（）
glutInitDisplayMode（GLUT_RGB | GLUT_单）
glutInitWindowPosition（100100）
GLUTINITWindowsSize（500500）
glutCreateWindow（“中点圆”）
glClearColor（0.5,0.5,0.5,0）
glMatrixMode（GL_投影）
gluOrtho2D（0.0500.0,0.0500.0）
glutDisplayFunc（myDisplay）
glutMainLoop（）

确保在像素中心绘制点和线基本体。由于顶点通过投影矩阵（和模型视图矩阵）进行变换，如果通过积分坐标指定顶点，则可能会出现不准确的情况：

glBegin（GL\u行\u循环）
glVertex2f（100+0.5100+0.5）
glVertex2f（150+0.5100+0.5）
glVertex2f（150+0.5150+0.5）
格伦德（）

当然，您必须在

getColor

中使用

x

和

y

坐标

glReadPixels（122、101、1、1、GL\u RGB、GL\u UNSIGNED\u BYTE、color）

glReadPixels（x，y，1，1，GL\u RGB，GL\u无符号字节，颜色）

元组是可比较的，因此

rgbColorEqual

的实现很容易：

def rgbColorEqual（c1、c2）：
返回c1[0]==c2[0]

如果

interiorColor

不等于

borderColor

且不等于

fillColor

，则必须

setPixel

并继续递归算法：

def boundaryFill4（x、y、fillColor、borderColor）：
interiorColor=getColor（x，y）
如果不是RGBColorQual（interiorColor，borderColor）且不是RGBColorQual（interiorColor，fillColor）：
设置像素（x，y）
boundaryFill4（x+1，y，fillColor，borderColor）
boundaryFill4（x-1，y，fillColor，borderColor）
boundaryFill4（x，y+1，fillColor，borderColor）
boundaryFill4（x，y-1，fillColor，borderColor）

getColor

返回的颜色通道在[0255]范围内。我建议通过相同范围内的值设置颜色属性（

glColor3ubv

）：

def myDisplay（）：
glClear（GLU颜色缓冲位）
#设置填充色为A.红色
#设置边界色为B蓝色
a=（255,0,0）
b=（0,0255）
GL3UBV（b）
#绘制三角形的边
glBegin（GL_线_环）
glVertex2f（100+0.5100+0.5）
glVertex2f（150+0.5100+0.5）
glVertex2f（150+0.5150+0.5）
格伦德（）
glFlush（）
#取图形中的一点，进行填充
GL3UBV（a）
边界填充4（120106，a，b）
glFlush（）

请参见示例：

#-*-编码：utf-8-*-
从OpenGL.GL导入*
从OpenGL.GLU导入*
从OpenGL.GLUT导入*
#判断c1，c2的颜色是否相同
def RGB颜色要求（c1、c2）：
返回c1[0]==c2[0]
#绘制像素点（x，y）
def设置像素（x，y）：
glBegin（GLU点）
glVertex2f（x+0.5，y+0.5）
格伦德（）
glFlush（）
返回
#获得点（x，y）的颜色
def getColor（x，y）：
颜色=（胶水*1）（0）
#读取点（x，y）的颜色颜色
glReadPixels（x，y，1，1，GL_RGB，GL_无符号字节，颜色）
颜色=int（颜色[0]）
r=255色
g=（颜色>>8）和255
b=（颜色>>16）和255
颜色=（r、g、b）
返回颜色
#4-连通边界填充算法
def boundaryFill4（x、y、fillColor、borderColor）：
interiorColor=getColor（x，y）
如果不是RGBColorQual（interiorColor，borderColor）且不是RGBColorQual（interiorColor，fillColor）：
设置像素（x，y）
boundaryFill4（x+1，y，fillColor，borderColor）
boundaryFill4（x-1，y，fillColor，borderColor）
boundaryFill4（x，y+1，fillColor，borderColor）
boundaryFill4（x，y-1，fillColor，borderColor）
glFlush（）
#显示函数
def myDisplay（）：
glClear（GL_颜色_浅黄色