Qual è un modo corretto per bloccare il rumore di dithering?

Quando si riduce la profondità del colore e il dithering con un rumore a 2 bit (con n =] 0,5,1,5 [e output = floor (input * (2 ^ bit-1) + n)), le estremità dell'intervallo di valori (input 0.0 e 1.0 ) sono rumorosi. Sarebbe desiderabile averli di colore solido.

Esempio: https://www.shadertoy.com/view/llsfz4

(sopra è uno screenshot dello shadertoy, raffigurante una sfumatura ed entrambe le estremità che dovrebbero essere rispettivamente bianche e nere solide, ma invece sono rumorose)

Naturalmente il problema può essere risolto semplicemente comprimendo l'intervallo di valori in modo che le estremità vengano sempre arrotondate a valori singoli. Questo sembra un po 'un trucco, e mi chiedo se c'è un modo per implementare questo "correttamente"?

TL; DR: il dithering triangolare in pdf 2 * 1LSB si rompe in un caso a 0 e 1 a causa del bloccaggio. Una soluzione è quella di aggrapparsi a una dithering uniforme a 1 bit in quei bordi.

Sto aggiungendo una seconda risposta, visto che si è rivelato un po 'più complicato di quanto pensassi inizialmente. Sembra che questo problema sia stato un "TODO: ha bisogno di essere bloccato?" nel mio codice da quando sono passato dal dithering normalizzato a quello triangolare ... nel 2012. Mi sento bene a guardarlo finalmente :) Codice completo per soluzione / immagini utilizzate in tutto il post: https://www.shadertoy.com/view/llXfzS

Prima di tutto, ecco il problema che stiamo osservando, quando si quantizza un segnale a 3 bit con dithering triangolare in pdf 2 * 1LSB:

- essenzialmente ciò che ha mostrato hotmultimedia.

Aumentando il contrasto, l'effetto descritto nella domanda diventa evidente: l'output non raggiunge la media in bianco e nero nelle edgecase (e in realtà si estende ben oltre lo 0/1 prima di farlo).

Guardare un grafico fornisce un po 'più di comprensione:

(le linee grigie indicano 0/1, anche in grigio è il segnale che stiamo cercando di emettere, la linea gialla è la media dell'uscita retinata / quantizzata, il rosso è l'errore (media del segnale)).

È interessante notare che non solo l'output medio non è 0/1 ai limiti, ma non è anche lineare (probabilmente a causa del pdf triangolare del rumore). Osservando l'estremità inferiore, ha un senso intuitivo il motivo per cui l'uscita diverge: quando il segnale retinato inizia a includere valori negativi, il serraggio sull'uscita cambia il valore delle parti retinate inferiori dell'uscita (cioè i valori negativi), quindi aumentando il valore della media. Un'illustrazione sembra essere in ordine (dithering 2LSB uniforme, simmetrica, media ancora in giallo):

Ora, se usiamo solo un dithering normalizzato da 1LSB, non ci sono problemi ai bordi dei casi, ma ovviamente perdiamo le belle proprietà del dithering triangolare (vedi ad esempio questa presentazione ).

Una soluzione (pragmatica, empirica) (hack), quindi, è di tornare a [-0,5; 0,5 [dithering uniforme per l'edgecase:

float dithertri = (rnd.x + rnd.y - 1.0); //note: symmetric, triangular dither, [-1;1[
float dithernorm = rnd.x - 0.5; //note: symmetric, uniform dither [-0.5;0.5[

float sizt_lo = clamp( v/(0.5/7.0), 0.0, 1.0 );
float sizt_hi = 1.0 - clamp( (v-6.5/7.0)/(1.0-6.5/7.0), 0.0, 1.0 );

dither = lerp( dithernorm, dithertri, min(sizt_lo, sizt_hi) );

Il che risolve le edgecase mantenendo intatto il dithering triangolare per l'intervallo rimanente:

Quindi, per non rispondere alla tua domanda: non so se esiste una soluzione matematicamente più solida e sono altrettanto desideroso di sapere cosa hanno fatto i Masters of Past :) Fino ad allora, almeno abbiamo questo orribile hack per mantenere il nostro codice funzionante.

EDIT
Probabilmente dovrei coprire il suggerimento-soluzione fornito in The Question, sulla semplice compressione del segnale. Poiché la media non è lineare nelle edgecase, la semplice compressione del segnale di input non produce un risultato perfetto, sebbene risolva gli endpoint:

Riferimenti

• https://www.shadertoy.com/view/llXfzS
• http://loopit.dk/rendering_inside.pdf
• http://loopit.dk/banding_in_games.pdf
• http://32ipi028l5q82yhj72224m8j-wpengine.netdna-ssl.com/wp-content/uploads/2016/03/GdcVdrLottes.pdf

Non sono sicuro di poter rispondere pienamente alla tua domanda, ma aggiungerò alcuni pensieri e forse potremo arrivare a una risposta insieme :)

In primo luogo, il fondamento della domanda non è chiaro per me: perché ritieni opportuno avere un bianco / nero pulito quando ogni altro colore ha rumore? Il risultato ideale dopo il dithering è il segnale originale con un rumore completamente uniforme. Se il bianco e nero sono diversi, il rumore diventa dipendente dal segnale (il che potrebbe andare bene, dal momento che accade comunque quando i colori sono bloccati).

Detto questo, ci sono situazioni in cui il rumore nei bianchi o nei neri pone un problema (non sono a conoscenza di casi che richiedono che sia il bianco che il nero siano "puliti"): quando si esegue il rendering di una particella additivamente miscelata come un quad con una trama, non si desidera aggiungere rumore nell'intero quad, poiché ciò si manifesterebbe anche al di fuori della trama. Una soluzione è compensare il rumore, quindi piuttosto che aggiungere [-0,5; 1,5 [si aggiunge [-2,0; 0,0 [(cioè sottrarre 2 bit di rumore). Questa è una soluzione abbastanza empirica, ma non sono consapevole di un approccio più corretto. Pensandoci, probabilmente vorrai anche aumentare il tuo segnale per compensare l'intensità perduta ...

In qualche modo correlato, Timothy Lottes ha tenuto una conferenza GDC sulla modellatura del rumore nelle parti dello spettro in cui è maggiormente necessario, riducendo il rumore nella parte più luminosa dello spettro: http://32ipi028l5q82yhj72224m8j-wpengine.netdna-ssl.com/wp- content / uploads / 2016/03 / GdcVdrLottes.pdf

Ho semplificato l'idea di Mikkel Gjoel di dithering con rumore triangolare a una semplice funzione che necessita solo di una singola chiamata RNG. Ho rimosso tutti i bit non necessari, quindi dovrebbe essere abbastanza leggibile e comprensibile cosa sta succedendo:

// Dithers and quantizes color value c in [0, 1] to the given color depth.
// It's expected that rng contains a uniform random variable on [0, 1].
uint dither_quantize(float c, uint depth, float rng) {
    float cmax = float(depth) - 1.0;
    float ci = c * cmax;

    float d;
    if (ci < 0.5 || ci >= cmax - 0.5) {
        // Uniform distribution on [-0.5, 0.5] for edges.
        d = rng - 0.5;
    } else {
        // Symmetric triangular distribution on [-1, 1].
        d = (rng < 0.5) ? sqrt(2.0 * rng) - 1.0 : 1.0 - sqrt(2.0 - 2.0*rng);
    }

    return uint(clamp(ci + d + 0.5, 0.0, cmax));
}

Per l'idea e il contesto ti rimando alla risposta di Mikkel Gjoel.