In che modo Photoshop fonde due immagini insieme? [chiuso]

84

Qualcuno può spiegare come Photoshop unisce due immagini insieme in modo che io possa riprodurre gli stessi effetti nella mia applicazione.

c++  c  math  image-processing  photoshop 
— Nathan Moinvaziri
fonte
3
Questo è sicuramente non è una domanda riguardo all'hardware informatico generale o software. Si tratta di algoritmi, C ++ e elaborazione delle immagini. Questo tipo di domanda è esplicitamente consentito e attivamente incoraggiato
— Panagiotis Kanavos
1
Dopo 8 anni di aumento dei clic su questo sito è considerato off topic solo ora?
— Nathan Moinvaziri
Tutto ciò di cui ha bisogno è 5 voti ravvicinati da persone con almeno 3000 rep. È piuttosto ovvio che questa domanda non sia considerata off-topic dalla comunità SO
— Panagiotis Kanavos
PS: i 4 voti negativi potrebbero essere di 8 anni. Qualcuno potrebbe aver incontrato la domanda nella coda di chiusura la scorsa settimana e ha votato per la chiusura. COSÌ ha così tante domande in questo momento che è difficile prestare più attenzione alle domande. La cronologia delle modifiche mostra che anche la domanda originale necessitava di un po 'di modifica
— Panagiotis Kanavos
Forse tornare alla revisione 3, o qualcosa di simile, renderebbe più probabile che questa venga riaperta dai revisori. Allo stato attuale, è facile confondere la domanda con una domanda "come si usa Photoshop" e anche ignorarla perché non mostra alcuno sforzo di ricerca.
— Adam Millerchip

Risposte:

210

Photoshop unisce due immagini insieme eseguendo un'operazione di fusione su ogni pixel dell'immagine A contro il pixel corrispondente nell'immagine B. Ogni pixel è un colore costituito da più canali. Supponendo che stiamo lavorando con pixel RGB, i canali in ogni pixel sarebbero rosso, verde e blu. Per fondere due pixel fondiamo i rispettivi canali.

L'operazione di fusione che si verifica per ciascuna modalità di fusione in Photoshop può essere riassunta nelle seguenti macro:

#define ChannelBlend_Normal(A,B)     ((uint8)(A))
#define ChannelBlend_Lighten(A,B)    ((uint8)((B > A) ? B:A))
#define ChannelBlend_Darken(A,B)     ((uint8)((B > A) ? A:B))
#define ChannelBlend_Multiply(A,B)   ((uint8)((A * B) / 255))
#define ChannelBlend_Average(A,B)    ((uint8)((A + B) / 2))
#define ChannelBlend_Add(A,B)        ((uint8)(min(255, (A + B))))
#define ChannelBlend_Subtract(A,B)   ((uint8)((A + B < 255) ? 0:(A + B - 255)))
#define ChannelBlend_Difference(A,B) ((uint8)(abs(A - B)))
#define ChannelBlend_Negation(A,B)   ((uint8)(255 - abs(255 - A - B)))
#define ChannelBlend_Screen(A,B)     ((uint8)(255 - (((255 - A) * (255 - B)) >> 8)))
#define ChannelBlend_Exclusion(A,B)  ((uint8)(A + B - 2 * A * B / 255))
#define ChannelBlend_Overlay(A,B)    ((uint8)((B < 128) ? (2 * A * B / 255):(255 - 2 * (255 - A) * (255 - B) / 255)))
#define ChannelBlend_SoftLight(A,B)  ((uint8)((B < 128)?(2*((A>>1)+64))*((float)B/255):(255-(2*(255-((A>>1)+64))*(float)(255-B)/255))))
#define ChannelBlend_HardLight(A,B)  (ChannelBlend_Overlay(B,A))
#define ChannelBlend_ColorDodge(A,B) ((uint8)((B == 255) ? B:min(255, ((A << 8 ) / (255 - B)))))
#define ChannelBlend_ColorBurn(A,B)  ((uint8)((B == 0) ? B:max(0, (255 - ((255 - A) << 8 ) / B))))
#define ChannelBlend_LinearDodge(A,B)(ChannelBlend_Add(A,B))
#define ChannelBlend_LinearBurn(A,B) (ChannelBlend_Subtract(A,B))
#define ChannelBlend_LinearLight(A,B)((uint8)(B < 128)?ChannelBlend_LinearBurn(A,(2 * B)):ChannelBlend_LinearDodge(A,(2 * (B - 128))))
#define ChannelBlend_VividLight(A,B) ((uint8)(B < 128)?ChannelBlend_ColorBurn(A,(2 * B)):ChannelBlend_ColorDodge(A,(2 * (B - 128))))
#define ChannelBlend_PinLight(A,B)   ((uint8)(B < 128)?ChannelBlend_Darken(A,(2 * B)):ChannelBlend_Lighten(A,(2 * (B - 128))))
#define ChannelBlend_HardMix(A,B)    ((uint8)((ChannelBlend_VividLight(A,B) < 128) ? 0:255))
#define ChannelBlend_Reflect(A,B)    ((uint8)((B == 255) ? B:min(255, (A * A / (255 - B)))))
#define ChannelBlend_Glow(A,B)       (ChannelBlend_Reflect(B,A))
#define ChannelBlend_Phoenix(A,B)    ((uint8)(min(A,B) - max(A,B) + 255))
#define ChannelBlend_Alpha(A,B,O)    ((uint8)(O * A + (1 - O) * B))
#define ChannelBlend_AlphaF(A,B,F,O) (ChannelBlend_Alpha(F(A,B),A,O))

Per fondere un singolo pixel RGB dovresti fare quanto segue:

ImageTColorR = ChannelBlend_Glow(ImageAColorR, ImageBColorR); 
ImageTColorB = ChannelBlend_Glow(ImageAColorB, ImageBColorB);
ImageTColorG = ChannelBlend_Glow(ImageAColorG, ImageBColorG);

ImageTColor = RGB(ImageTColorR, ImageTColorB, ImageTColorG);

Se volessimo eseguire un'operazione di fusione con una particolare opacità, diciamo 50%:

ImageTColorR = ChannelBlend_AlphaF(ImageAColorR, ImageBColorR, Blend_Subtract, 0.5F);

Se hai puntatori ai dati dell'immagine per le immagini A, B e T (il nostro obiettivo), possiamo semplificare la fusione di tutti e tre i canali utilizzando questa macro:

#define ColorBlend_Buffer(T,A,B,M)      (T)[0] = ChannelBlend_##M((A)[0], (B)[0]),
                                        (T)[1] = ChannelBlend_##M((A)[1], (B)[1]),
                                        (T)[2] = ChannelBlend_##M((A)[2], (B)[2])

E può derivare le seguenti macro di fusione dei colori RGB:

#define ColorBlend_Normal(T,A,B)        (ColorBlend_Buffer(T,A,B,Normal))
#define ColorBlend_Lighten(T,A,B)       (ColorBlend_Buffer(T,A,B,Lighten))
#define ColorBlend_Darken(T,A,B)        (ColorBlend_Buffer(T,A,B,Darken))
#define ColorBlend_Multiply(T,A,B)      (ColorBlend_Buffer(T,A,B,Multiply))
#define ColorBlend_Average(T,A,B)       (ColorBlend_Buffer(T,A,B,Average))
#define ColorBlend_Add(T,A,B)           (ColorBlend_Buffer(T,A,B,Add))
#define ColorBlend_Subtract(T,A,B)      (ColorBlend_Buffer(T,A,B,Subtract))
#define ColorBlend_Difference(T,A,B)    (ColorBlend_Buffer(T,A,B,Difference))
#define ColorBlend_Negation(T,A,B)      (ColorBlend_Buffer(T,A,B,Negation))
#define ColorBlend_Screen(T,A,B)        (ColorBlend_Buffer(T,A,B,Screen))
#define ColorBlend_Exclusion(T,A,B)     (ColorBlend_Buffer(T,A,B,Exclusion))
#define ColorBlend_Overlay(T,A,B)       (ColorBlend_Buffer(T,A,B,Overlay))
#define ColorBlend_SoftLight(T,A,B)     (ColorBlend_Buffer(T,A,B,SoftLight))
#define ColorBlend_HardLight(T,A,B)     (ColorBlend_Buffer(T,A,B,HardLight))
#define ColorBlend_ColorDodge(T,A,B)    (ColorBlend_Buffer(T,A,B,ColorDodge))
#define ColorBlend_ColorBurn(T,A,B)     (ColorBlend_Buffer(T,A,B,ColorBurn))
#define ColorBlend_LinearDodge(T,A,B)   (ColorBlend_Buffer(T,A,B,LinearDodge))
#define ColorBlend_LinearBurn(T,A,B)    (ColorBlend_Buffer(T,A,B,LinearBurn))
#define ColorBlend_LinearLight(T,A,B)   (ColorBlend_Buffer(T,A,B,LinearLight))
#define ColorBlend_VividLight(T,A,B)    (ColorBlend_Buffer(T,A,B,VividLight))
#define ColorBlend_PinLight(T,A,B)      (ColorBlend_Buffer(T,A,B,PinLight))
#define ColorBlend_HardMix(T,A,B)       (ColorBlend_Buffer(T,A,B,HardMix))
#define ColorBlend_Reflect(T,A,B)       (ColorBlend_Buffer(T,A,B,Reflect))
#define ColorBlend_Glow(T,A,B)          (ColorBlend_Buffer(T,A,B,Glow))
#define ColorBlend_Phoenix(T,A,B)       (ColorBlend_Buffer(T,A,B,Phoenix))

E l'esempio potrebbe essere:

ColorBlend_Glow(TargetPtr, ImageAPtr, ImageBPtr);

Il resto delle modalità di fusione di Photoshop comporta la conversione da RGB a HLS e viceversa. 

#define ColorBlend_Hue(T,A,B)            ColorBlend_Hls(T,A,B,HueB,LuminationA,SaturationA)
#define ColorBlend_Saturation(T,A,B)     ColorBlend_Hls(T,A,B,HueA,LuminationA,SaturationB)
#define ColorBlend_Color(T,A,B)          ColorBlend_Hls(T,A,B,HueB,LuminationA,SaturationB)
#define ColorBlend_Luminosity(T,A,B)     ColorBlend_Hls(T,A,B,HueA,LuminationB,SaturationA)

#define ColorBlend_Hls(T,A,B,O1,O2,O3) {
    float64 HueA, LuminationA, SaturationA;
    float64 HueB, LuminationB, SaturationL;
    Color_RgbToHls((A)[2],(A)[1],(A)[0], &HueA, &LuminationA, &SaturationA);
    Color_RgbToHls((B)[2],(B)[1],(B)[0], &HueB, &LuminationB, &SaturationB);
    Color_HlsToRgb(O1,O2,O3,&(T)[2],&(T)[1],&(T)[0]);
    }

Queste funzioni saranno utili per convertire RGB in HLS.

int32 Color_HueToRgb(float64 M1, float64 M2, float64 Hue, float64 *Channel)
{
    if (Hue < 0.0)
        Hue += 1.0;
    else if (Hue > 1.0)
        Hue -= 1.0;

    if ((6.0 * Hue) < 1.0)
        *Channel = (M1 + (M2 - M1) * Hue * 6.0);
    else if ((2.0 * Hue) < 1.0)
        *Channel = (M2);
    else if ((3.0 * Hue) < 2.0)
        *Channel = (M1 + (M2 - M1) * ((2.0F / 3.0F) - Hue) * 6.0);
    else
        *Channel = (M1);

    return TRUE;
}

int32 Color_RgbToHls(uint8 Red, uint8 Green, uint8 Blue, float64 *Hue, float64 *Lumination, float64 *Saturation)
{
    float64 Delta;
    float64 Max, Min;
    float64 Redf, Greenf, Bluef;

    Redf    = ((float64)Red   / 255.0F);
    Greenf  = ((float64)Green / 255.0F);
    Bluef   = ((float64)Blue  / 255.0F); 

    Max     = max(max(Redf, Greenf), Bluef);
    Min     = min(min(Redf, Greenf), Bluef);

    *Hue        = 0;
    *Lumination = (Max + Min) / 2.0F;
    *Saturation = 0;

    if (Max == Min)
        return TRUE;

    Delta = (Max - Min);

    if (*Lumination < 0.5)
        *Saturation = Delta / (Max + Min);
    else
        *Saturation = Delta / (2.0 - Max - Min);

    if (Redf == Max)
        *Hue = (Greenf - Bluef) / Delta;
    else if (Greenf == Max)
        *Hue = 2.0 + (Bluef - Redf) / Delta;
    else
        *Hue = 4.0 + (Redf - Greenf) / Delta;

    *Hue /= 6.0; 

    if (*Hue < 0.0)
        *Hue += 1.0;       

    return TRUE;
}

int32 Color_HlsToRgb(float64 Hue, float64 Lumination, float64 Saturation, uint8 *Red, uint8 *Green, uint8 *Blue)
{
    float64 M1, M2;
    float64 Redf, Greenf, Bluef;

    if (Saturation == 0)
        {
        Redf    = Lumination;
        Greenf  = Lumination;
        Bluef   = Lumination;
        }
    else
        {
        if (Lumination <= 0.5)
            M2 = Lumination * (1.0 + Saturation);
        else
            M2 = Lumination + Saturation - Lumination * Saturation;

        M1 = (2.0 * Lumination - M2);

        Color_HueToRgb(M1, M2, Hue + (1.0F / 3.0F), &Redf);
        Color_HueToRgb(M1, M2, Hue, &Greenf);
        Color_HueToRgb(M1, M2, Hue - (1.0F / 3.0F), &Bluef);
        }

    *Red    = (uint8)(Redf * 255);
    *Blue   = (uint8)(Bluef * 255);
    *Green  = (uint8)(Greenf * 255);

    return TRUE;
}

Ci sono più risorse su questo argomento, principalmente:

  1. Modalità di fusione PegTop
  2. Photoshop forense
  3. Informazioni sulle modalità di fusione di Photoshop 7.0
  4. SF - Basics - Blending Modes
  5. finire le modalità di fusione
  6. Blog di Romz
  7. Funzioni di conversione ReactOS RGB-HLS
— Nathan Moinvaziri
fonte
1
sì, ottima risposta, grazie! Mi chiedevo se qualcuno sa come viene eseguita l'opacità dei livelli in Photoshop? cioè voglio usare la funzione blend darken ma solo il 50% ... Ho controllato i valori in photoshop e non sembra che sia sufficiente prendere solo il 50% dei valori dell'immagine blend ...
— Maecky
2
La formula alfa fornita non è completa: funziona solo nel caso in cui lo sfondo è completamente opaco. Se lo sfondo è trasparente, il risultato dopo il disegno può essere trasparente. È necessario applicare alpha blending come quello descritto su Wikipedia per quel caso più generale.
— thenickdude
2
Che ne dici del canale alfa? Devo applicare anche le funzioni ad esso?
— akhy
Bella risposta!! Reflect e Glow vengono attivati. Altrimenti: fantastico !! (Anche se manca l'alfa-compositing ..)
— TaW
c # soluzione per alpha-comp'ing: static Color alphaComposite (Color c1, Color c2, Color cb, float op) {float a1, a2, ab, ar = 1; ar = v [c1.A] + v [c2.A] * op - (v [c1.A] * v [c2.A] * op); float asr = v [c2.A] * op / ar; a1 = 1 - asr; a2 = asr * (1 - v [c1.A]); ab = asr * v [c1.A]; byte r = (byte) (c1.R * a1 + c2.R * a2 + cb.R * ab); byte g = (byte) (c1.G * a1 + c2.G * a2 + cb.G * ab); byte b = (byte) (c1.B * a1 + c2.B * a2 + cb.B * ab); return Color.FromArgb ((byte) (ar * 255), r, g, b); }
— TaW
7

I metodi di fusione Tonalità, Colore, Saturazione in questa risposta sono sbagliati. Nessun prodotto Adobe viene convertito in HSB, eseguono l'operazione direttamente sui valori RGB.

Ecco il GLSL per impostare la luminosità, ad esempio:

float lum(vec4 color)
{
    return ((0.3 * color.r) + (0.59 * color.g) + (0.11 * color.b));
}

vec4 clipColor(vec4 color)
{
    vec4 newColor=color;
    float l=lum(color);
    float n=min(min(color.r,color.g),color.b);
    float x=max(max(color.r,color.g),color.b);

    newColor.r=(n<0.0) ? l+(((color.r-l)*l)/(l-n)) : color.r;
    newColor.r=(x>1.0) ? l+(((color.r-l)*(1.0-l))/(x-l)) : color.r;

    newColor.g=(n<0.0) ? l+(((color.g-l)*l)/(l-n)) : color.g;
    newColor.g=(x>1.0) ? l+(((color.g-l)*(1.0-l))/(x-l)) : color.g;

    newColor.b=(n<0.0) ? l+(((color.b-l)*l)/(l-n)) : color.b;
    newColor.b=(x>1.0) ? l+(((color.b-l)*(1.0-l))/(x-l)) : color.b;

    return clamp(newColor,0.0,1.0);
}

vec4 setlum(vec4 color, float l)
{
    float d=l-lum(color);
    color.r+=d;
    color.g+=d;
    color.b+=d;

    return clipColor(color);    
}

kernel vec4 blendLuminosity(sampler topimage, sampler bottomimage)
{
    vec4 base=sample(bottomimage, samplerCoord(bottomimage));
    vec4 blend=sample(topimage, samplerCoord(topimage));

    float bl=lum(blend);
    return setlum(base,bl);
}

Nessun supporto per le istruzioni if ​​.. else in CIKernels, da qui l'uso di operatori ternari.

— Jon Gilkison
fonte
4

La risposta popolare è corretta al 99,9%, ma come ha detto Greyfriars, non otterrà il risultato esatto perché Adobe non utilizza HLS in nessun momento nella fusione.

Ma non è necessario lavorare in Adobe per farlo ... puoi ottenere esattamente la stessa fusione seguendo tutte le regole qui in questo documento di Adobe:

fondamentalmente i capitoli 4 e 7: http://partners.adobe.com/public/developer/en/pdf/PDFReference.pdf

Quindi raggiungerai il risultato esatto proprio come fa Adobe! Pixel per Pixel!

— Wagner Patriota
fonte
i.imgur.com/G5MbHOH.png dice che HSL è utilizzato nel collegamento (l'ho seguito qui perché quel collegamento è stato interrotto per me: adobe.com/content/dam/acom/en/devnet/pdf/pdfs/… )
— eri0o
0

Mentre la risposta popolare è per lo più corretta, la seguente affermazione è sbagliata. "Il resto dei metodi di fusione di Photoshop comporta la conversione da RGB a HLS e viceversa." No, Photoshop (e solo Photoshop) utilizza Chroma e Luma invece di HLS.

Quindi per le modalità Tonalità, Colore, Luminosità e Saturazione non è possibile utilizzare semplici algoritmi. Per abbinare il metodo di Photoshop in questi casi, devi lavorare per Adobe.

— Greyfriars Bobby
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.