5

我正在使用 (Py)OpenGL 来显示 256 色索引图像。我将着色器与包含调色板的一维纹理一起使用。这是片段着色器代码：

#version 330
uniform sampler2D texture; 
uniform sampler1D palette;

void main() 
{ 
    vec2 uv = gl_TexCoord[0].xy; 
    vec4 color = texture2D(texture, uv); 
    gl_FragColor = texture1D(palette, color.a) ;
}

为避免舍入误差，所有 MAG 和 MIN 过滤器都设置为 NEAREST。

我看到一维纹理的纹理坐标的方式是：

  • 颜色 0 位于区间 [0 ; 1/256[
  • 颜色 1 位于区间 [1/256 ; 2/256[ ...
  • 颜色 255 位于区间 [255/256 ; 1[

我将自己的整数索引转换为在 0 和 1 之间浮动，以确保发生了什么，使用公式 x_float = (x_int + .4)/256，即 x_float 在前面提到的间隔内，在它的中心之前一点（到避免结果在间隔的错误一侧四舍五入）。

但它不起作用。我制作了一个包含 256 个单元格的棋盘，颜色索引为 0 到 255，灰度等级为调色板（从 0x000000 到 0xFFFFFF）。代码如下。然后我制作了一个屏幕快照并在 Paint.NET 中对其进行了编辑，以查看颜色是否正确，并注意到颜色 0xE0 的跳跃：我得到了两次颜色 0xDF，并且从这个颜色中，所有内容都移动了一个：最后一种颜色是 0xFE 0xFF。

我怀疑某种舍入错误，但不知道如何......

这是完整的代码：

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

from OpenGL.arrays import vbo
from OpenGL.GL import shaders
from numpy import *

def checkboard(size = 512, cell = 32):
    bitmap = zeros(size * size, 'u8')
    bitmap.shape = (size, size)
    current_color = 0

    for y in range(0, size, cell):
        for x in range(0, size, cell):
            bitmap[y : y + cell, x : x + cell] = current_color
            current_color += 1

    palette = array([[a, a, a, 255] for a in range(256)], 'u8')

    return bitmap, palette

def reshape(w, h):
    glutDisplayFunc(lambda: display(w, h))
    glutPostRedisplay();

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(512, 512)
glutCreateWindow("Hello World :'D")

### init code

# vbo
quad = (0.0, 0.0, 512.0, 512.0)
tex = (0., 0., 1., 1.)

my_vbo = vbo.VBO(
        array( [
            ( quad[0], quad[1], 0, tex[0], tex[1]),
            ( quad[0], quad[3], 0, tex[0], tex[3]),
            ( quad[2], quad[3], 0, tex[2], tex[3]),
            ( quad[2], quad[1], 0, tex[2], tex[1])
        ],'f,f,f,f,f')
    )

# texture
bitmap, palette = checkboard()
height, width = bitmap.shape
f_image = (array(bitmap, 'f') + .4) / 256.0

# Image to be displayed
image_id = glGenTextures(1)
glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, image_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0,
             GL_ALPHA, GL_FLOAT, f_image)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glActiveTexture(GL_TEXTURE0)

# palette
f_palette = (palette / float32(255))

palette_id = glGenTextures(1)
glEnable(GL_TEXTURE_1D)
glBindTexture(GL_TEXTURE_1D, palette_id)
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0,
             GL_RGBA, GL_FLOAT, f_palette)
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
#glActiveTexture(GL_TEXTURE1)

# shaders
VERTEX_SHADER = shaders.compileShader("""#version 330

layout(location = 0) in vec4 position;
uniform vec2 offset ;

void main()
{
      gl_FrontColor = gl_Color;
      gl_TexCoord[0].xy = gl_MultiTexCoord0.xy;
      gl_Position = vec4((offset.x + position.x - 256) / 256, (256 - offset.y - position.y)/256, 0.0, 1.0);
}""", GL_VERTEX_SHADER)

FRAGMENT_SHADER = shaders.compileShader("""#version 330
    uniform sampler2D texture; 
    uniform sampler1D palette;

    void main() 
    { 
        vec2 uv = gl_TexCoord[0].xy; 
        vec4 color = texture2D(texture, uv); 
        gl_FragColor = texture1D(palette, color.a) ;
    }""", GL_FRAGMENT_SHADER)

shader = shaders.compileProgram(VERTEX_SHADER,FRAGMENT_SHADER)

# uniform variables
offset_uniform_loc = glGetUniformLocation(shader, "offset")
texture_uniform_loc = glGetUniformLocation(shader, 'texture' )
palette_uniform_loc = glGetUniformLocation(shader, 'palette' )


def display(w, h):
    """Render the geometry for the scene."""
    glViewport(0, 0, w, h)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    glOrtho(0, w, 0, h, -1, 1)

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity()

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    glEnable( GL_TEXTURE_2D )
    glActiveTexture( GL_TEXTURE0 )
    glBindTexture( GL_TEXTURE_2D, image_id)

    glEnable( GL_TEXTURE_1D )
    glActiveTexture( GL_TEXTURE1 )

    shaders.glUseProgram(shader)
    shaders.glUniform1i(texture_uniform_loc, 0)
    shaders.glUniform1i(palette_uniform_loc, 1)
    shaders.glUniform2f(offset_uniform_loc, 0, 0)

    try:
        my_vbo.bind()
        try:
            glEnableClientState(GL_VERTEX_ARRAY)
            glEnableClientState(GL_TEXTURE_COORD_ARRAY)
            glVertexPointer(3, GL_FLOAT, 20, my_vbo)
            glTexCoordPointer(2, GL_FLOAT, 20, my_vbo + 12)

            glBindTexture( GL_TEXTURE_1D, palette_id)
            glDrawArrays(GL_QUADS, 0, 4)
        finally:
            my_vbo.unbind()
            glDisableClientState(GL_TEXTURE_COORD_ARRAY)
            glDisableClientState(GL_VERTEX_ARRAY)
    finally:
        shaders.glUseProgram( 0 )

    glutSwapBuffers()


glutReshapeFunc(reshape)
glutIdleFunc(glutPostRedisplay)
glutMainLoop()
4

1 回答 1

6

用于GL_CLAMP_TO_EDGE您的纹理GL_TEXTURE_WRAP_S。

出现此问题的部分原因是纹理坐标1.0引用了超出最后一个纹素中心的位置。Clamp to edge 将使您的坐标在该S方向上被夹在边缘纹素的中心。

当对纹理进行采样时，如果坐标不指代精确的纹素中心，则过滤器模式和环绕行为将决定从哪里获取纹素。默认情况下，OpenGL 使用重复模式，因此纹理坐标接近1.0的最近邻居（最近的纹理中心）可能来自纹理的另一侧（重复）。对于普通图像，您甚至可能不会注意到这种行为，但是当您绕过查找表的另一侧时，不连续性可能非常明显。

这是说明这一点的图表：

http://i.msdn.microsoft.com/dynimg/IC83860.gif

请注意纹理坐标1.0实际上是如何指代调色板条目3和0之间的边界的？

简短的版本是，如果您的范围是从0.0到1.0，那么您的纹理坐标都没有引用纹素中心，您可以轻松地结束对错误纹素的采样。您需要调整坐标，以免每个调色板条目都使用纹素边界。

或者，由于您使用的是 GLSL ≥ 130，您可以使用texelFetch (...)并完全跳过所有这些归一化纹理坐标的废话。如果您想使用其a组件获取纹理的调色板条目，请尝试以下操作：

gl_FragColor = texelFetch (palette, (int)(texture2D (texture, uv).a * 255.0), 0);

这将显式获取整数索引给出的纹素。您不必担心最近邻、环绕模式、过滤等。

于 2013-10-11T17:28:12.163 回答