Rendering sub-pixel in OpenGL - problema di accuratezza

Question

Devo generare alcune serie di immagini di prova per un'applicazione fotogrammetrica. Questi dovrebbero contenere oggetti semplici (dischi, rettangoli, ecc.) Con una posizione ben nota.

Considerando un'immagine in scala di grigi a 8 bit di un rettangolo nero su sfondo bianco, un minimo spostamento osservabile (dopo l'interpolazione) deve essere di 1/256 pixel, in quanto vi sono 256 livelli di intensità possibili per ciascun pixel.

ho deciso di utilizzare OpenGL (con pitone + pyglet) per rendere tali immagini, come in seguito dovrò rendere più complicate (3d scena, coppie di immagini stereo)

Purtroppo, la migliore precisione che hanno raggiunto è intorno a pixel/10, la profondità dell'intensità totale non viene utilizzata.

È possibile fare meglio, idealmente - ottenendo una precisione di 1/256pixel? Qualche suggerimento su come farlo, per favore?

codice di esempio, generando immagini di un disco parziale, spostato 0,01 pixel più in ciascun frame

#-*- coding: utf-8 -*- 
import pyglet 
from pyglet.gl import * 
from PIL import Image, ImageGrab 

config = pyglet.gl.Config(width = 800, height = 600, sample_buffers=1, samples=16) 
window = pyglet.window.Window(config=config, resizable=True) 
window.set_size(800, 600) 

printScreenNr = 0 

@window.event 
def on_draw(): 
    global printScreenNr 
    window.clear() 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glLoadIdentity() 
    glEnable(GL_LINE_SMOOTH) 
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); 

    glTranslated(200, 200,0) 

    circleQuad = gluNewQuadric() 
    glTranslated(200+(printScreenNr*0.01), 0, 0) 
    gluPartialDisk(circleQuad, 0, 50, 500, 500, 0, 180) 

@window.event 
def on_resize(width, height): 
    glViewport(0, 0, width, height) 
    glMatrixMode(GL_PROJECTION) 
    glLoadIdentity() 
    glOrtho (0, width, height, 0, 0, 1); 
    glMatrixMode(GL_MODELVIEW) 
    return pyglet.event.EVENT_HANDLED 

@window.event 
def on_text(text): 
    global printScreenNr 
    if(text == "p"): 
     pyglet.image.get_buffer_manager().get_color_buffer().save('photo'+str(printScreenNr)+'.tiff') 
     printScreenNr += 1 

pyglet.app.run() 

(il codice precedente utilizza gluPartialDisk, ma Ho testato il problema utilizzando anche quadrilateri, precisione dei risultati fatto non diverso)

Answer 1

Un modo semplice per farlo è ridimensionare l'immagine di un fattore. Se ridimensionate l'immagine per 4.0, 16 pixel originali verranno uniti in un pixel di destinazione che fornisce 16 sfumature di grigio quando si ridimensiona un'immagine pura B & W.

Ma c'è un problema che probabilmente spiega il tuo problema. Se avete questo:

...##### 
    ...##### 
    ...##### 
    ...##### 

(a sinistra: bianco, a destra: nero rettangolo pieno), allora si hanno 12 bianco e 4 pixel neri che contribuiscono a un singolo pixel di uscita. Per ottenere 1 pixel nero, l'ingresso avrebbe bisogno di essere questo:

....#### 
    ....#### 
    ....#### 
    ...##### 

Vedi? Anche se la scatola nera perde solo un pixel nello spazio bianco, lo fa quattro volte. Quindi, per assicurarti che il tuo codice di rendering subpixel funzioni, devi guardare i singoli pixel o gli angoli, non i bordi.

Answer 2

Anche se si utilizza la proiezione ortogonale, GL_PERSPECTIVE_CORRECTION_HINT potrebbe influire sulla precisione del rendering. Almeno ricordo vagamente glHint (GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); risolvendo alcune lacune nella mia scena proiettata ortogonalmente molti anni fa.