Vui lòng giải thích công thức chế độ hòa trộn màu này để tôi có thể sao chép nó trong PHP/ImageMagick

Question

Tôi đã cố gắng sử dụng ImageMagick để tái tạo Chế độ hòa trộn màu của photoshop. Tôi tìm thấy các công thức sau đây trong một online guide nhưng tôi không biết ý nghĩa của chúng. Tôi chỉ cần trao đổi một số kênh nhất định?

Answer 1

A là điểm ảnh Foreground, B là các điểm ảnh nền, C là các điểm ảnh mới. H là giá trị Hue cho mỗi pixel, S là giá trị Saturation, L là giá trị Độ sáng, và Y là giá trị Độ sáng. (Tuy nhiên, trong ví dụ đầu tiên, giá trị Hue (H) và Saturation (S) của pixel mới (C) được sao chép từ điểm ảnh Foreground (A). trong khi giá trị Brightness (Y) của điểm ảnh mới được lấy từ giá trị Luminance (L) của nền (B) pixel.

Answer 2

Wikipedia có một bài viết tốt về chế độ pha trộn http://en.wikipedia.org/wiki/Blend_modes

Họ cung cấp cho các công thức cho Chế độ nhân, màn hình và lớp phủ.

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

Cách đây không lâu, tôi đã đảo ngược chế độ hoà trộn Photoshop được thiết kế.

Có một cái nhìn ở đây:

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

Và đây bên dưới đoạn code tôi sử dụng để chuyển đổi giữa HSY (Hue, Saturation, Luminosity) đến và đi từ RGB (Red, Green, Blue). Photoshop sử dụng thứ gọi là Hexacones để tính toán độ bão hòa.

Giovanni

/** 
* 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

Những công thức pha trộn màu khá phức tạp nếu bạn cần phải kết hợp chặt chẽ cũng là kênh alpha. Tôi đã không thể tái tạo sự pha trộn của Photoshop, nhưng Gimp làm việc như thế này:

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

Nếu bạn sử dụng alpha premultiplied, đừng quên để xử lý một cách chính xác nó trong đoạn mã trên. Tôi đã không thể tìm thấy mã để pha trộn trong mã nguồn của GIMP, nhưng các hình ảnh kết quả là rất giống nhau.

pha trộn màu sắc của Photoshop rõ ràng là khác nhau, vì vậy nếu có ai tìm thấy một cách để thực hiện nó, xin vui lòng cho tất cả chúng ta biết: o)

Miso