इस रंग सम्मिश्रण मोड सूत्र की व्याख्या करें तो मैं PHP/ImageMagick

Question

मैं ImageMagick उपयोग करना Photoshops रंग मिश्रण मोड को दोहराने की कोशिश कर रहा है में यह दोहराने कर सकते हैं। मैं एक online guide में निम्नलिखित सूत्र पाया, लेकिन मैं नहीं जानता कि वे क्या मतलब है। क्या मुझे बस कुछ चैनलों को स्वैप करने की ज़रूरत है?

Answer 1

एक अग्रभूमि पिक्सेल है, बी पृष्ठभूमि पिक्सेल, सी नई पिक्सेल है। एच प्रत्येक पिक्सेल के लिए ह्यू मूल्य है, एस संतृप्ति मूल्य है, एल Luminance मूल्य है, और वाई चमक मूल्य है। (सुनिश्चित नहीं है कि चमक और चमक के बीच अंतर क्या है।

वैसे भी, पहले उदाहरण में नए पिक्सेल (सी) के ह्यू (एच) और संतृप्ति (एस) मानों को अग्रभूमि पिक्सेल (ए) से कॉपी किया गया है। जबकि नए पिक्सेल की चमक (वाई) मूल्य पृष्ठभूमि (बी) पिक्सेल की चमक (एल) मूल्य से लिया जाता है।

Answer 2

विकिपीडिया मिश्रण मोड पर एक अच्छा लेख http://en.wikipedia.org/wiki/Blend_modes

वे के लिए फार्मूले देना है गुणा, स्क्रीन और मोड ओवरले।

Multiply 
Formula: Result Color = (Top Color) * (Bottom Color) /255 

Screen 
Formula: Result Color = 255 - [((255 - Top Color)*(255 - Bottom Color))/255] 

Overlay 
Formula: Result Color = if (Bottom Color < 128) 
    then (2 * Top Color * Bottom Color/255) 
    else (255 - 2 * (255 - Top Color) * (255 - Bottom Color)/255) 

Answer 3

कुछ समय पहले मैं इंजीनियर उलट फ़ोटोशॉप सम्मिश्रण मोड।

http://www.kineticsystem.org/?q=node/13

और यहाँ कोड मैं करने के लिए और आरजीबी (लाल, हरा, नीला) से HSY (रंग, संतृप्तता, दीप्ति) के बीच परिवर्तित करने के लिए उपयोग करने के लिए नीचे दिए गए:

यहाँ एक नज़र डालें। फ़ोटोशॉप संतृप्ति की गणना करने के लिए हेक्साकोन्स नामक कुछ का उपयोग करें।

जियोवानी

/** 
* This is the formula used by Photoshop to convert a color from 
* RGB (Red, Green, Blue) to HSY (Hue, Saturation, Luminosity). 
* The hue is calculated using the exacone approximation of the saturation 
* cone. 
* @param rgb The input color RGB normalized components. 
* @param hsy The output color HSY normalized components. 
*/ 
public static void rgbToHsy(double rgb[], double hsy[]) { 

    double r = Math.min(Math.max(rgb[0], 0d), 1d); 
    double g = Math.min(Math.max(rgb[1], 0d), 1d); 
    double b = Math.min(Math.max(rgb[2], 0d), 1d); 

    double h; 
    double s; 
    double y; 

    // For saturation equals to 0 any value of hue are valid. 
    // In this case we choose 0 as a default value. 

    if (r == g && g == b) {   // Limit case. 
     s = 0d; 
     h = 0d; 
    } else if ((r >= g) && (g >= b)) { // Sector 0: 0° - 60° 
     s = r - b; 
     h = 60d * (g - b)/s; 
    } else if ((g > r) && (r >= b)) { // Sector 1: 60° - 120° 
     s = g - b; 
     h = 60d * (g - r)/s + 60d; 
    } else if ((g >= b) && (b > r)) { // Sector 2: 120° - 180° 
     s = g - r; 
     h = 60d * (b - r)/s + 120d; 
    } else if ((b > g) && (g > r)) { // Sector 3: 180° - 240° 
     s = b - r; 
     h = 60d * (b - g)/s + 180d; 
    } else if ((b > r) && (r >= g)) { // Sector 4: 240° - 300° 
     s = b - g; 
     h = 60d * (r - g)/s + 240d; 
    } else {       // Sector 5: 300° - 360° 
     s = r - g; 
     h = 60d * (r - b)/s + 300d; 
    } 

    y = R * r + G * g + B * b; 

    // Approximations erros can cause values to exceed bounds. 

    hsy[0] = h % 360; 
    hsy[1] = Math.min(Math.max(s, 0d), 1d); 
    hsy[2] = Math.min(Math.max(y, 0d), 1d); 
} 

/** 
* This is the formula used by Photoshop to convert a color from 
* HSY (Hue, Saturation, Luminosity) to RGB (Red, Green, Blue). 
* The hue is calculated using the exacone approximation of the saturation 
* cone. 
* @param hsy The input color HSY normalized components. 
* @param rgb The output color RGB normalized components. 
*/ 
public static void hsyToRgb(double hsy[], double rgb[]) { 

    double h = hsy[0] % 360; 
    double s = Math.min(Math.max(hsy[1], 0d), 1d); 
    double y = Math.min(Math.max(hsy[2], 0d), 1d); 

    double r; 
    double g; 
    double b; 

    double k; // Intermediate variable. 

    if (h >= 0d && h < 60d) {   // Sector 0: 0° - 60° 
     k = s * h/60d; 
     b = y - R * s - G * k; 
     r = b + s; 
     g = b + k; 
    } else if (h >= 60d && h < 120d) { // Sector 1: 60° - 120° 
     k = s * (h - 60d)/60d; 
     g = y + B * s + R * k; 
     b = g - s; 
     r = g - k; 
    } else if (h >= 120d && h < 180d) { // Sector 2: 120° - 180° 
     k = s * (h - 120d)/60d; 
     r = y - G * s - B * k; 
     g = r + s; 
     b = r + k; 
    } else if (h >= 180d && h < 240d) { // Sector 3: 180° - 240° 
     k = s * (h - 180d)/60d; 
     b = y + R * s + G * k; 
     r = b - s; 
     g = b - k; 
    } else if (h >= 240d && h < 300d) { // Sector 4: 240° - 300° 
     k = s * (h - 240d)/60d; 
     g = y - B * s - R * k; 
     b = g + s; 
     r = g + k; 
    } else {       // Sector 5: 300° - 360° 
     k = s * (h - 300d)/60d; 
     r = y + G * s + B * k; 
     g = r - s; 
     b = r - k; 
    } 

    // Approximations erros can cause values to exceed bounds. 

    rgb[0] = Math.min(Math.max(r, 0d), 1d); 
    rgb[1] = Math.min(Math.max(g, 0d), 1d); 
    rgb[2] = Math.min(Math.max(b, 0d), 1d); 
} 

Answer 4

ये रंग सम्मिश्रण सूत्रों काफी मुश्किल है, तो आप भी अल्फ़ा चैनल को शामिल करने की जरूरत है। मैं फ़ोटोशॉप का सम्मिश्रण प्रजनन करने में सक्षम नहीं था, लेकिन Gimp इस तरह काम करता है:

Color mix_hsv(
    ColorMixMode::Enum mode, // blending mode 
    Color cd,    // destination color (bottom pixel) 
    Color cs)    // source color (top pixel) 
{ 
    // Modify the source color 
    float dh, ds, dv; // destination hsv 
    float sh, ss, sv; // source hsv 
    cd.GetHsv(dh, ds, dv); 
    cs.GetHsv(sh, ss, sv); 

    switch (mode) { 
     case HUE:  cs.InitFromHsv(sh, ds, dv); break; 
     case SATURATION: cs.InitFromHsv(dh, ss, dv); break; 
     case COLOR:  cs.InitFromHsv(sh, ss, dv); break; 
     case LUMINOSITY: cs.InitFromHsv(dh, ds, sv); break; 
    } 
    cs.A = std::min(cd.A, cs.A); 

    // Blend the modified source color onto the destination color 
    unsigned char cd_A_orig = cd.A; 
    cd = mix(NORMAL, cd, cs); // normal blending 
    cd.A = cd_A_orig; 
    return cd; 
} 

आप premultiplied अल्फा का उपयोग करते हैं, मत भूलना सही ढंग से उपरोक्त कोड में इसे संभाल करने के लिए। मैं Gimp के स्रोत कोड में मिश्रण के लिए कोड को खोजने के लिए सक्षम नहीं था, लेकिन इसके परिणाम स्वरूप छवियों बहुत समान हैं।

फ़ोटोशॉप के रंग सम्मिश्रण स्पष्ट रूप से अलग है, इसलिए किसी को भी इसे लागू करने के लिए एक तरह से यह पता लगता है, हम सभी को अवगत कराएं: ओ)

मिसो