Algoritmo de mesclagem de camadas (1)

Exibição comum de resultados mistos

Escurecer a camada após misturar

modo normal

Misturar Cor*Opacidade+(100% - Opacidade da Cor Misturada)

void layerblend_normal(Mat &base,Mat &blend,Mat &dst,float opacity)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++)
                d3[cw + c] = opacity * d1[cw + c] + (1.0f - opacity) * d2[cw + c];
        }
    }
}

Dissolver

Se a opacidade e o preenchimento da cor misturada no modo dissolver forem 100%, não conseguiremos ver a camada de cor base. Depois de diminuir a opacidade da camada de cores mescladas, notaremos que há muitas partículas minúsculas na cor resultante. Essas partículas mudam com a opacidade da cor de mesclagem. Quanto menor a opacidade, mais a camada de cores mescladas será dissolvida. A menor parte resta. Quanto maior a opacidade, menos parte da camada de cor mesclada é dissolvida e mais sobra, e mais próxima a cor resultante estará da cor mesclada.

escuridão

No modo de mistura de escurecimento, ele comparará a cor misturada com a cor base e selecionará o menor valor entre os três grupos de valores R, G e B, ou seja, a cor mais escura, como valor da cor resultante. Isso deixará toda a imagem mais escura e, se for uma imagem colorida, a cor também mudará bastante. (Não haverá alteração se a posição for trocada)

void layerblend_darkness(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++)
                d3[cw + c] = d1[cw + c] < d2[cw + c] ? d1[cw + c] : d2[cw + c];
        }
    }
}

Multiplicar

Princípio de mistura multiplicada: É calculado com base nos valores R, G e B da cor misturada e da cor base. A fórmula de cálculo é: cor resultante R = cor misturada R * cor base R / 255. O valor G e o valor B são calculados da mesma maneira. Os valores finais de R, G e B obtidos são as cores das cores resultantes. Como o valor máximo de cada canal é 255, o valor da cor resultante é menor que os valores da cor misturada e da cor base, ou seja, a cor resultante é mais escura. (Não haverá alteração se a posição for trocada)

void layerblend_multiply(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++)
                d3[cw + c] = 1.0f * d1[cw + c] * d2[cw + c] / 255;
        }
    }
}

cor escura

O Color Burn pode adicionar escuridão rapidamente a uma imagem. Sua fórmula de cálculo: Cor resultado = (cor base + cor mista - 255) * 255 / cor mista. Dentre eles (cor base + cor mista - 255), se houver um número negativo, ele retornará 0 diretamente. Portanto, quando a cor base e a cor misturada forem escuras, elas se tornarão diretamente pretas. Isso aumentará a escuridão da cor resultante. O efeito geral parece relativamente forte em contraste.

void layerblend_color_dark(Mat &base,Mat &blend,Mat &dst)
{
    if (base.rows != blend.rows ||
        base.cols != blend.cols ||
        base.type() != blend.type())
        return;

    dst = Mat::zeros(base.rows,base.cols,base.type());

    for (int h = 0;h < base.rows;h ++)
    {
        uchar *d1 = base.ptr<uchar>(h);
        uchar *d2 = blend.ptr<uchar>(h);
        uchar *d3 = dst.ptr<uchar>(h);
        for (int w = 0;w < base.cols;w ++)
        {
            int cw = w * base.channels();
            for (int c = 0;c < base.channels();c ++){
                d3[cw + c] = 1.0f * d1[cw + c] * d2[cw + c] / 255;

                 int temp = d1[cw + c] + d2[cw + c] - 255;

                 temp = temp < 0 ? 0 : temp;

                 int res = 0;
                 if (d2[cw + c] == 0)
                     res = d1[cw + c];
                 else
                     res = temp * 255.0f / d2[cw + c];

                 d3[cw + c] = saturate_cast<uchar>(res);
            }
        }
    }
}

Modo escuro (escuro)

O modo de mesclagem escuro é mais fácil de entender. Ele calcula os valores de todos os canais da cor misturada e da cor base e, a seguir, seleciona o valor menor como cor resultante. Portanto, a cor resultante é igual à cor de mistura ou à cor base e nenhuma outra cor é produzida. O branco é misturado com a cor base para obter a cor base, e o preto é misturado com a cor base para obter o preto. No modo escuro, os valores da cor misturada e da cor base são fixos. Depois de invertermos as posições, a cor resultante da cor misturada não muda. Este modo é semelhante ao modo escurecimento.