Apa cara yang tepat untuk menjepit kebisingan?

Ketika mengurangi kedalaman warna dan dithering dengan noise 2 bit (dengan n =] 0,5,1.5 [dan output = lantai (input * (2 ^ bit-1) + n)), ujung rentang nilai (input 0,0 dan 1,0 ) berisik. Akan diinginkan untuk memilikinya menjadi warna solid.

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

(di atas adalah tangkapan layar shadertoy, menggambarkan gradien dan kedua ujungnya yang masing-masing harus solid putih dan hitam, tetapi sebaliknya berisik)

Masalahnya tentu saja dapat diselesaikan dengan hanya mengompresi rentang nilai sehingga ujungnya selalu dibulatkan menjadi nilai tunggal. Ini terasa sedikit hack, dan saya bertanya-tanya apakah ada cara untuk menerapkan ini "dengan benar"?

TL; DR: 2 * 1LSB istirahat dithering triangular-pdf dalam edgecases pada 0 dan 1 karena penjepitan. Solusinya adalah lerp ke seragam 1bit di edgecases tersebut.

Saya menambahkan jawaban kedua, mengingat ini ternyata sedikit lebih rumit dari yang saya kira. Tampaknya masalah ini telah menjadi "TODO: perlu dijepit?" dalam kode saya sejak saya beralih dari normalisasi menjadi dithering triangular ... pada 2012. Terasa senang akhirnya melihatnya :) Kode lengkap untuk solusi / gambar yang digunakan di seluruh pos: https://www.shadertoy.com/view/llXfzS

Pertama-tama, di sini adalah masalah yang sedang kita bahas, ketika menghitung sinyal menjadi 3bits dengan 2 * 1LSB dithering triangular-pdf:

- pada dasarnya apa yang ditampilkan hotmultimedia.

Semakin kontras, efek yang dijelaskan dalam pertanyaan menjadi jelas: Outputnya tidak rata-rata menjadi hitam / putih di edgecases (dan benar-benar melampaui 0/1 sebelum melakukannya).

Melihat grafik memberikan sedikit lebih banyak wawasan:

(garis abu-abu menandai 0/1, juga dalam abu-abu adalah sinyal yang kami coba untuk keluaran, garis kuning adalah rata-rata dari keluaran yang terkutuk / dikuantisasi, merah adalah kesalahan (rata-rata sinyal)).

Menariknya, tidak hanya output rata-rata tidak 0/1 pada batasnya, tetapi juga tidak linier (kemungkinan karena pdf segitiga dari kebisingan). Melihat ujung yang lebih rendah, masuk akal secara intuitif mengapa output menyimpang: Ketika sinyal ragu-ragu mulai memasukkan nilai-nilai negatif, clamping-on-output mengubah nilai dari bagian-bagian output yang berkerut rendah (yaitu nilai negatif), dengan demikian meningkatkan nilai rata-rata. Sebuah ilustrasi tampak berurutan (seragam, 2LSB simetris, rata-rata masih berwarna kuning):

Sekarang, jika kita hanya menggunakan 1LSB yang dinormalisasi, tidak ada masalah sama sekali, tapi tentu saja kita kehilangan sifat bagus dari dithering segitiga (lihat misalnya presentasi ini ).

Maka (hack) solusi (pragmatis, empiris), adalah kembali ke [-0,5; 0,5 [dithering seragam untuk 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) );

Yang memperbaiki edgecases sambil menjaga dithering segitiga tetap utuh untuk rentang yang tersisa:

Jadi untuk tidak menjawab pertanyaan Anda: Saya tidak tahu apakah ada solusi yang lebih kuat secara matematis, dan sama-sama tertarik untuk mengetahui apa yang telah dilakukan Masters of Past :) Sampai saat itu, setidaknya kami memiliki peretasan yang mengerikan ini untuk menjaga kode kami berfungsi.

EDIT
Saya mungkin harus membahas saran-solusi yang diberikan dalam Pertanyaan, pada hanya menekan sinyal. Karena rata-rata tidak linier dalam edgecases, cukup mengompresi sinyal input tidak menghasilkan hasil yang sempurna - meskipun itu memperbaiki titik akhir:

Referensi

• 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

Saya tidak yakin saya bisa sepenuhnya menjawab pertanyaan Anda, tetapi saya akan menambahkan beberapa pemikiran dan mungkin kita bisa sampai pada jawaban bersama :)

Pertama, dasar dari pertanyaan ini agak tidak jelas bagi saya: Mengapa Anda menganggap perlu untuk membersihkan hitam / putih ketika setiap warna lain memiliki noise? Hasil ideal setelah dithering adalah sinyal asli Anda dengan noise yang sepenuhnya seragam. Jika hitam dan putih berbeda, noise Anda menjadi bergantung pada sinyal (yang mungkin baik-baik saja, karena itu terjadi di mana warna tetap dijepit).

Yang mengatakan, ada beberapa situasi, di mana memiliki kebisingan baik putih atau hitam memang menimbulkan masalah (saya tidak mengetahui penggunaan kata-kata yang mengharuskan hitam dan putih secara bersamaan menjadi "bersih"): Ketika membuat partikel campuran aditif sebagai quad dengan tekstur, Anda tidak ingin noise ditambahkan di seluruh quad, karena itu akan menunjukkan tekstur di luar juga. Salah satu solusinya adalah dengan mengimbangi kebisingan, jadi daripada menambahkan [-0,5; 1,5 [Anda menambahkan [-2,0; 0,0 [(yaitu kurangi 2 bit noise). Ini merupakan solusi empiris, tetapi saya tidak mengetahui pendekatan yang lebih tepat. Berpikir tentang itu, Anda mungkin juga ingin meningkatkan sinyal Anda untuk mengimbangi kehilangan intensitas ...

Agak terkait, Timothy Lottes melakukan pembicaraan GDC pada pembentukan suara ke bagian dari spektrum di mana hal ini sangat diperlukan, mengurangi kebisingan di akhir terang spektrum: http://32ipi028l5q82yhj72224m8j-wpengine.netdna-ssl.com/wp- konten / unggah / 2016/03 / GdcVdrLottes.pdf

Saya telah menyederhanakan ide Mikkel Gjoel tentang dithering dengan noise segitiga menjadi fungsi sederhana yang hanya membutuhkan satu panggilan RNG. Saya telah menghapus semua bit yang tidak perlu sehingga harus mudah dibaca dan dimengerti apa yang terjadi:

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

Untuk gagasan dan konteksnya, saya akan merujuk Anda ke jawaban Mikkel Gjoel.

Saya mengikuti tautan ke pertanyaan luar biasa ini bersama dengan contoh shadertoy.

Saya punya beberapa pertanyaan tentang solusi yang disarankan:

1. Apa nilai v? Apakah ini sinyal RGB dalam kisaran 0,0 hingga 1,0 (hitam ke putih) yang ingin kami kuantifikasi? Apakah itu pelampung tunggal? (dan jika demikian, bagaimana Anda menghitungnya dari sinyal RGB asli?)
2. Apa sumber "angka ajaib" 0,5 / 7,0? Saya berasumsi itu setengah bin, tapi saya berharap bahwa ukuran bin diwakili oleh 8 bit menjadi 1,0 / 255,0, jadi saya terkejut melihat 0,5 / 0,7. Apakah Anda keberatan menjelaskan bagaimana Anda memperoleh angka-angka ini. Apa yang saya lewatkan?
3. Saya mengasumsikan distribusi segitiga berada dalam kisaran [-1,1] dan seragamnya berada di [-0,5,0,5] ("setengah bit" karena kami dekat ke tepi dan kami tidak ingin overshoot - apakah itu logika yang Anda terapkan?)
4. Variabel acak seragam dan segitiga harus independen. Apakah saya benar?

Kerja bagus! Saya ingin melihat bahwa saya memahami garis pemikiran Anda dengan benar. Terima kasih!