Apakah alpha yang di-preultiplied memberikan transparansi yang independen?

Saya pernah mendengar bahwa alpha pra-dikalikan memberi Anda memesan transparansi independen tetapi ketika saya duduk dan melakukan matematika, itu tampaknya tidak berfungsi.

Apakah itu tidak benar, atau saya melakukan sesuatu yang salah?

Formula yang saya gunakan adalah:

$out_{rgba} = in_{rgba} + out_{rgba} * (1 - in_a)$

dimana adalah alpha yang -nestultiplied. Dengan kata lain, mengambil warna "normal" dalam RGBA, saya mengalikan RGB dengan a. 30% buram putih akan mulai sebagai (1, 1, 1, 0,3) tetapi akan menjadi (0,3, 0,3, 0,3, 0,3) sebagai alfa yang telah diultipipasi.$in$

Setelah mendapatkan jawaban yang salah ketika mengerjakannya dengan tangan, saya menulis program C ++ di bawah ini dan saya masih mendapatkan hasil yang salah.

Setelah eksekusi:

$out1 = (0.738, 0.913, 0.3, 1.0)\\ out2 = (0.738, 0.875, 0.113, 1.0)$

Adakah yang bisa menjelaskan mengapa?

#include <array>

typedef std::array<float, 4> RGBA;

void PremultiplyAlpha (RGBA& rgba)
{
    rgba[0] *= rgba[3];
    rgba[1] *= rgba[3];
    rgba[2] *= rgba[3];
}

RGBA BlendPremultipliedAlpha (const RGBA& dest, const RGBA& src)
{
    RGBA ret;
    ret[0] = src[0] + dest[0] * (1.0f - src[3]);
    ret[1] = src[1] + dest[1] * (1.0f - src[3]);
    ret[2] = src[2] + dest[2] * (1.0f - src[3]);
    ret[3] = src[3] + dest[3] * (1.0f - src[3]);
    return ret;
}

int main(int argc, char **argv)
{
    RGBA greenGround = { 0.0f, 1.0f, 0.0f, 1.0f };
    PremultiplyAlpha(greenGround);

    RGBA red25PercentOpaque = { 1.0f, 0.0f, 0.0f, 0.25f };
    PremultiplyAlpha(red25PercentOpaque);

    RGBA white30PercentOpaque = { 1.0f, 1.0f, 1.0f, 0.3f };
    PremultiplyAlpha(white30PercentOpaque);

    RGBA yellow50PercentOpaque = { 1.0f, 1.0f, 0.0f, 0.5f };
    PremultiplyAlpha(yellow50PercentOpaque);

    // one way
    RGBA out1;
    {
        // start with the green ground and blend in 25% opaque red
        out1 = greenGround;
        out1 = BlendPremultipliedAlpha(out1, red25PercentOpaque);

        // then blend in 50% yellow
        out1 = BlendPremultipliedAlpha(out1, yellow50PercentOpaque);

        // then blend in 30% opaque white
        out1 = BlendPremultipliedAlpha(out1, white30PercentOpaque);
    }

    // other way
    RGBA out2;
    {
        // start with the green ground and blend in 30% opaque white
        out2 = greenGround;
        out2 = BlendPremultipliedAlpha(out2, white30PercentOpaque);

        // then blend in 25% red
        out2 = BlendPremultipliedAlpha(out2, red25PercentOpaque);

        // then blend in 50% yellow
        out2 = BlendPremultipliedAlpha(out2, yellow50PercentOpaque);
    }

    return 0;
}

Alfa yang di-premultiplied sendiri tidak memberi Anda transparansi yang independen, tidak.

Namun halaman ini berbicara tentang bagaimana ia dapat digunakan sebagai bagian dari solusi transparansi independen pesanan: http://casual-effects.blogspot.com/2015/03/implemented-weighted-blended-order.html

Manfaat lain dari alfa yang telah di-multipultifikasi meliputi:

• peta jalan yang lebih baik untuk tekstur yang mengandung alfa: https://developer.nvidia.com/content/alpha-blending-pre-or-not-pre

• Mampu melakukan transparansi dan campuran aditif dalam satu tekstur tanpa perlu mengubah status render atau mengeluarkan beberapa panggilan seri: http://amindforeverprogramming.blogspot.com/2013/07/why-alpha-premultiplied-colour-blending.html

• Mampu mewakili situasi pencahayaan yang lebih realistis, seperti fakta bahwa menjadi tidak buram tidak selalu berarti transparansi: http://distantsoulsdev.blogspot.com.ar/2013/02/premultiplied-alpha-online-interactive.html

• Mampu untuk secara lebih alami / benar / mudah menggabungkan gambar yang memiliki saluran alfa.

• Mampu mendapatkan hasil yang lebih baik dari pemrosesan gambar (blur / konvolusi). Tidak ada lingkaran hitam: /programming/4854839/how-to-use-pre-multiplied-during-image-convolution-to-solve-alpha-bleed-problem

• Alfa prapultiplied juga memungkinkan objek transparan ditarik dari depan ke belakang alih-alih dari belakang ke depan, mungkin menghemat penulisan piksel.

Dari bukti pencampuran alfa yang telah ditiru sebelumnya, ada asumsi bahwa "operator harus menghormati aturan asosiatif." Jadi, ini dapat menyebabkan kebingungan pada urutan proses.

Karena ini bukan aturan komutatif, campuran (a, b) tidak sama dengan campuran (b, a).

Karenanya, campuran (campuran (a, b), c) menghasilkan nilai campuran yang sama (a, campuran (b, c)). tetapi, campuran (campuran (a, b), c) tidak menghasilkan nilai campuran yang sama (campuran (b, a), c) seperti contoh Anda.

Alan, artikel pengomposisian Jim Blinn juga menjelaskan mengapa premultiplied adalah cara yang tepat untuk melakukan penyaringan gambar transparan.