¿Cuál es una forma adecuada de sujetar el ruido de oscilación?

Al reducir la profundidad de color y el tramado con un ruido de 2 bits (con n =] 0.5,1.5 [y salida = piso (entrada * (2 ^ bits-1) + n)), los extremos del rango de valores (entradas 0.0 y 1.0 ) son ruidosos Sería deseable que tuvieran un color sólido.

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

(arriba hay una captura de pantalla del dibujo sombreado, que muestra un gradiente y ambos extremos que deberían ser blancos y negros sólidos, respectivamente, pero que son ruidosos)

Por supuesto, el problema se puede resolver simplemente comprimiendo el rango de valores para que los extremos siempre se redondeen a valores únicos. Sin embargo, esto se siente como un truco, y me pregunto si hay una manera de implementar esto "correctamente".

TL; DR: 2 * 1LSB, el tramado triangular-pdf se rompe en las cajas de borde en 0 y 1 debido a la sujeción. Una solución es saltar a un tramado uniforme de 1 bit en esas cajas de borde.

Estoy agregando una segunda respuesta, ya que esto resultó un poco más complicado de lo que pensé originalmente. Parece que este problema ha sido un "TODO: ¿necesita sujeción?" en mi código desde que cambié de tramado normalizado a triangular ... en 2012. Se siente bien finalmente mirarlo :) Código completo para la solución / imágenes utilizadas en toda la publicación: https://www.shadertoy.com/view/llXfzS

En primer lugar, aquí está el problema que estamos viendo, cuando cuantificamos una señal a 3 bits con tramado triangular-pdf 2 * 1LSB:

- esencialmente lo que mostró hotmultimedia.

Al aumentar el contraste, el efecto descrito en la pregunta se hace evidente: la salida no se promedia en blanco y negro en los bordes (y en realidad se extiende más allá de 0/1 antes de hacerlo).

Mirar un gráfico proporciona un poco más de información:

(las líneas grises marcan 0/1, también en gris es la señal que estamos tratando de emitir, la línea amarilla es el promedio de la salida difuminada / cuantificada, el rojo es el error (promedio de la señal)).

Curiosamente, la salida promedio no solo no es 0/1 en los límites, sino que tampoco es lineal (probablemente debido al pdf triangular del ruido). Mirando el extremo inferior, tiene sentido intuitivo por qué la salida diverge: a medida que la señal difuminada comienza a incluir valores negativos, la sujeción en la salida cambia el valor de las partes difuminadas inferiores de la salida (es decir, los valores negativos), por lo tanto aumentando el valor de la media. Una ilustración parece estar en orden (uniforme, tramado simétrico de 2LSB, promedio todavía en amarillo):

Ahora, si solo usamos un tramado normalizado de 1LSB, no hay problemas en los bordes de los casos, pero luego, por supuesto, perdemos las buenas propiedades del tramado triangular (ver, por ejemplo, esta presentación ).

Entonces, una solución (pragmática, empírica) (piratear) es revertir a [-0.5; 0.5 [difuminado uniforme para el 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) );

Lo que repara las cajas de borde mientras mantiene intacta la oscilación triangular para el rango restante:

Entonces, para no responder a su pregunta: no sé si existe una solución matemáticamente más sólida, y estoy igualmente interesado en saber qué han hecho los Maestros del Pasado :) Hasta entonces, al menos tenemos este truco horrible para mantener nuestro código funcionando.

EDITAR
Probablemente debería cubrir la sugerencia de solución dada en La pregunta, simplemente comprimiendo la señal. Debido a que el promedio no es lineal en las cajas de borde, simplemente comprimir la señal de entrada no produce un resultado perfecto, aunque sí arregla los puntos finales:

Referencias

• 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

No estoy seguro de poder responder completamente a su pregunta, pero agregaré algunas ideas y tal vez podamos llegar a una respuesta juntos :)

Primero, la base de la pregunta es un poco confusa para mí: ¿por qué considera deseable tener un blanco / negro limpio cuando cualquier otro color tiene ruido? El resultado ideal después del tramado es su señal original con un ruido completamente uniforme. Si el blanco y el negro son diferentes, su ruido se vuelve dependiente de la señal (lo que podría estar bien, ya que de todos modos sucede donde los colores están sujetos).

Dicho esto, hay situaciones en las que tener ruido en blancos o negros plantea un problema (no estoy al tanto de los casos de uso que requieren que tanto el blanco como el negro estén "limpios" simultáneamente): cuando se procesa una partícula mezclada aditivamente como un quad con una textura, no desea que se agregue ruido en todo el quad, ya que eso también se vería fuera de la textura. Una solución es compensar el ruido, por lo que en lugar de sumar [-0.5; 1.5 [agrega [-2.0; 0.0 [(es decir, resta 2 bits de ruido). Esta es una solución bastante empírica, pero no estoy al tanto de un enfoque más correcto. Pensando en ello, es probable que también desee aumentar su señal para compensar la intensidad perdida ...

Algo relacionado, Timothy Lottes hizo una charla de GDC sobre la configuración del ruido en las partes del espectro donde más se necesita, reduciendo el ruido en el extremo brillante del espectro: http://32ipi028l5q82yhj72224m8j-wpengine.netdna-ssl.com/wp- content / uploads / 2016/03 / GdcVdrLottes.pdf

He simplificado la idea de Mikkel Gjoel de difuminar con ruido triangular a una función simple que solo necesita una sola llamada RNG. He eliminado todos los bits innecesarios, por lo que debería ser bastante legible y comprensible lo que está sucediendo:

// 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));
}

Para la idea y el contexto, lo remitiré a la respuesta de Mikkel Gjoel.

Seguí los enlaces a esta excelente pregunta junto con el ejemplo de sombreado.

Tengo algunas preguntas sobre la solución sugerida:

1. ¿Cuál es el valor v? ¿Es la señal RGB en el rango de 0.0 a 1.0 (negro a blanco) que queremos cuantificar? ¿Es un flotador único? (y si es así, ¿cómo lo calculó a partir de la señal RGB original?)
2. ¿Cuál es la fuente del "número mágico" 0.5 / 7.0? Supongo que es el medio bin, pero esperaría que el tamaño del bin representado por 8 bits sea 1.0 / 255.0, por lo que me sorprendió ver 0.5 / 0.7. ¿Te importaría explicar cómo obtuviste estos números? ¿Qué me estoy perdiendo?
3. Supongo que la distribución del triángulo está en el rango [-1,1] y el uniforme está en [-0.5,0.5] ("medio bit" porque nos acercamos al borde y no queremos sobrepasarnos), es que la lógica que aplicaste?
4. Las variables aleatorias uniformes y triangulares deben ser independientes. ¿Estoy en lo correcto?

¡Buen trabajo! Quiero ver que entendí tu línea de pensamiento correctamente. ¡Gracias!