Myślę, że to, czego szukasz, to formuła konwersji RGB -> Luma.

Fotometryczne / cyfrowe ITU BT.709:

Y = 0.2126 R + 0.7152 G + 0.0722 B

Digital ITU BT.601 (daje większą wagę składnikom R i B):

Y = 0.299 R + 0.587 G + 0.114 B

Jeśli chcesz wymienić dokładność na perfomancję, istnieją dwie formuły przybliżenia dla tej jednej:

Y = 0.33 R + 0.5 G + 0.16 B

Y = 0.375 R + 0.5 G + 0.125 B

Można je szybko obliczyć jako

Y = (R+R+B+G+G+G)/6

Y = (R+R+R+B+G+G+G+G)>>3

Dokonałem porównania trzech algorytmów w zaakceptowanej odpowiedzi. Wygenerowałem kolory w cyklu, w którym użyto tylko co 400-ty kolor. Każdy kolor jest reprezentowany przez 2x2 piksele, kolory są sortowane od najciemniejszych do najjaśniejszych (od lewej do prawej, od góry do dołu).

1. zdjęcie - Luminancja (względna)

0.2126 * R + 0.7152 * G + 0.0722 * B

2. Zdjęcie- http://www.w3.org/TR/AERT#color-contrast

0.299 * R + 0.587 * G + 0.114 * B

Trzecie zdjęcie- HSP Color Model

sqrt(0.299 * R^2 + 0.587 * G^2 + 0.114 * B^2)

4. zdjęcie - WCAG 2.0 SC 1.4.3 względna luminancja i współczynnik kontrastu Wzór (Zobacz @ Synchro ' s odpowiedź tutaj )

Wzór może być czasami zauważony na 1. i 2. obrazku w zależności od liczby kolorów w jednym rzędzie. Nigdy nie zauważyłem żadnego wzoru na zdjęciu z 3. lub 4. algorytmu.

Gdybym miał wybrać, wybrałbym algorytm numer 3, ponieważ jest znacznie łatwiejszy do wdrożenia i o 33% szybszy niż 4.

odpowiedź "przyjęta" jest niepoprawna i niekompletna

Krótko:

• sRGB musi być LINEARYZOWANE przed zastosowaniem współczynniki.
Luminancja (L lub Y) jest liniowa, podobnie jak światło.
• postrzegana lekkość (L*) jest nieliniowa, podobnie jak ludzka percepcja.
• HSV I HSL nie są nawet zdalnie dokładne pod względem percepcji.
• norma IEC dla sRGB określa próg 0,04045, to jest , a nie 0,03928 (to było z przestarzałego wcześniejszego projektu).
• przydatne (tj. względem percepcji) , odległości Euklidesowe wymagają percepcyjnie jednolitego Kartezjusza przestrzeń wektorowa, np. CIELAB. sRGB nie jest jednym z nich.

Poniżej znajduje się prawidłowa i kompletna odpowiedź:

Ponieważ ten wątek pojawia się wysoko w wyszukiwarkach, dodaję tę odpowiedź, aby wyjaśnić różne nieporozumienia na ten temat.

Luminancja jest liniową miarą światła, ważoną widmowo dla normalnego widzenia, ale nie dostosowaną do nieliniowej percepcji jasności. Może być miarą względną, Y {[58] } jak w CIEXYZ, lub jako L , miara bezwzględna w cd/M²(nie mylić z L*).

Postrzegana lekkość {[58] } jest używana przez niektóre modele widzenia, takie jak CIELAB, tutaj L* (Lstar) jest wartością percepcyjnej lekkości i jest nieliniowa, aby zbliżyć krzywą odpowiedzi nieliniowej ludzkiego wzroku.

Jasność jest atrybutem percepcyjnym, nie ma" fizycznej " miary. Jednak niektóre modele wyglądu kolorów mają wartość , zwykle oznaczana jako "Q" dla postrzeganej jasności, która jest inna niż postrzegana lekkość.

Luma (y prime) to sygnał kodowany gamma, ważony używany w niektórych kodowaniach wideo (YIQ). Nie należy jej mylić z luminancją liniową.

Gamma lub krzywa transferu (TRC) jest krzywą, która jest często podobna do krzywej percepcji i jest powszechnie stosowana do danych obrazu do przechowywania lub transmisji w celu zmniejszenia postrzegany szum i / lub poprawić wykorzystanie danych (i pokrewne powody).

Aby określić postrzeganą jasność, najpierw przekonwertuj wartości obrazu zakodowanego gamma RGB na luminancję liniową(L lub Y ) a następnie do nieliniowej postrzeganej lekkości (L*)

ABY ZNALEŹĆ LUMINANCJĘ:

...Bo najwyraźniej gdzieś się zgubił...

Krok Pierwszy:

Konwertuj wszystkie 8-bitowe wartości całkowite sRGB na dziesiętne 0.0-1.0

  vR = sR / 255;
  vG = sG / 255;
  vB = sB / 255;

Krok Drugi:

Konwersja gamma zakodowanego RGB na wartość liniową. sRGB (standard komputerowy) na przykład wymaga krzywej mocy w przybliżeniu v^2.2, chociaż" dokładna " transformata wynosi:

gdzie V to kodowany gamma kanał R, G lub B sRGB.
Pseudocode:

function sRGBtoLin(colorChannel) {
        // Send this function a decimal sRGB gamma encoded color value
        // between 0.0 and 1.0, and it returns a linearized value.

    if ( colorChannel <= 0.04045 ) {
            return colorChannel / 12.92;
        } else {
            return pow((( colorChannel + 0.055)/1.055),2.4));
        }
    }

Krok Trzeci:

Aby znaleźć luminancję (Y) zastosuj standardowe współczynniki dla sRGB:

Pseudokod wykorzystujący powyższe funkcje:

Y = (0.2126 * sRGBtoLin(vR) + 0.7152 * sRGBtoLin(vG) + 0.0722 * sRGBtoLin(vB))

ABY ZNALEŹĆ POSTRZEGANĄ LEKKOŚĆ:

Krok Czwarty:

Weź luminancję Y z góry i przekształć w L *

Pseudocode:

function YtoLstar(Y) {
        // Send this function a luminance value between 0.0 and 1.0,
        // and it returns L* which is "perceptual lightness"

    if ( Y <= (216/24389) {       // The CIE standard states 0.008856 but 216/24389 is the intent for 0.008856451679036
            return Y * (24389/27);  // The CIE standard states 903.3, but 24389/27 is the intent, making 903.296296296296296
        } else {
            return pow(Y,(1/3)) * 116 - 16;
        }
    }

L * to wartość od 0 (czarny) do 100 (biały), gdzie 50 to percepcyjny "środkowy szary". L * = 50 jest odpowiednikiem Y = 18,4, czyli 18% szarej karty, reprezentującej środek zdjęcia ekspozycja (Ansel Adams zone V).

Bibliografia:

IEC 61966-2-1:1999 Standard
Wikipedia sRGB
Wikipedia CIELAB
Wikipedia CIEXYZ
Charles Poynton ' s Gamma FAQ

Poniżej znajduje się jedyny poprawny algorytm konwersji obrazów sRGB, stosowanych w przeglądarkach itp., do skali szarości.

Konieczne jest zastosowanie odwrotności funkcji gamma dla przestrzeni kolorów przed obliczeniem iloczynu wewnętrznego. Następnie zastosujesz funkcję gamma do zmniejszonej wartości. Brak włączenia funkcji gamma może spowodować błędy do 20%.

Dla typowych rzeczy komputerowych, przestrzeń kolorów to sRGB. Właściwe liczby dla sRGB to ok. 0.21, 0.72, 0.07. Gamma dla sRGB jest funkcją złożoną, która przybliża wykładnictwo przez 1/(2.2). Oto całość w C++.

// sRGB luminance(Y) values
const double rY = 0.212655;
const double gY = 0.715158;
const double bY = 0.072187;

// Inverse of sRGB "gamma" function. (approx 2.2)
double inv_gam_sRGB(int ic) {
    double c = ic/255.0;
    if ( c <= 0.04045 )
        return c/12.92;
    else 
        return pow(((c+0.055)/(1.055)),2.4);
}

// sRGB "gamma" function (approx 2.2)
int gam_sRGB(double v) {
    if(v<=0.0031308)
        v *= 12.92;
    else 
        v = 1.055*pow(v,1.0/2.4)-0.055;
    return int(v*255+0.5); // This is correct in C++. Other languages may not
                           // require +0.5
}

// GRAY VALUE ("brightness")
int gray(int r, int g, int b) {
    return gam_sRGB(
            rY*inv_gam_sRGB(r) +
            gY*inv_gam_sRGB(g) +
            bY*inv_gam_sRGB(b)
    );
}

Zamiast zgubić się wśród losowego wyboru wzorów wymienionych tutaj, proponuję wybrać wzór zalecany przez standardy W3C.

Oto prosta, ale dokładna implementacja PHP WCAG 2.0 SC 1.4.3 względna luminancja i współczynnik kontrastu wzory. Tworzy wartości, które są odpowiednie do oceny wskaźników wymaganych dla zgodności WCAG, jak na ta strona, i jako takie jest odpowiednie i odpowiednie dla każdej sieci app. Jest to trywialne, aby przenieść do innych języków.

/**
 * Calculate relative luminance in sRGB colour space for use in WCAG 2.0 compliance
 * @link http://www.w3.org/TR/WCAG20/#relativeluminancedef
 * @param string $col A 3 or 6-digit hex colour string
 * @return float
 * @author Marcus Bointon <[email protected]>
 */
function relativeluminance($col) {
    //Remove any leading #
    $col = trim($col, '#');
    //Convert 3-digit to 6-digit
    if (strlen($col) == 3) {
        $col = $col[0] . $col[0] . $col[1] . $col[1] . $col[2] . $col[2];
    }
    //Convert hex to 0-1 scale
    $components = array(
        'r' => hexdec(substr($col, 0, 2)) / 255,
        'g' => hexdec(substr($col, 2, 2)) / 255,
        'b' => hexdec(substr($col, 4, 2)) / 255
    );
    //Correct for sRGB
    foreach($components as $c => $v) {
        if ($v <= 0.04045) {
            $components[$c] = $v / 12.92;
        } else {
            $components[$c] = pow((($v + 0.055) / 1.055), 2.4);
        }
    }
    //Calculate relative luminance using ITU-R BT. 709 coefficients
    return ($components['r'] * 0.2126) + ($components['g'] * 0.7152) + ($components['b'] * 0.0722);
}

/**
 * Calculate contrast ratio acording to WCAG 2.0 formula
 * Will return a value between 1 (no contrast) and 21 (max contrast)
 * @link http://www.w3.org/TR/WCAG20/#contrast-ratiodef
 * @param string $c1 A 3 or 6-digit hex colour string
 * @param string $c2 A 3 or 6-digit hex colour string
 * @return float
 * @author Marcus Bointon <[email protected]>
 */
function contrastratio($c1, $c2) {
    $y1 = relativeluminance($c1);
    $y2 = relativeluminance($c2);
    //Arrange so $y1 is lightest
    if ($y1 < $y2) {
        $y3 = $y1;
        $y1 = $y2;
        $y2 = $y3;
    }
    return ($y1 + 0.05) / ($y2 + 0.05);
}

Znalazłem Ten kod (napisany w C#), który doskonale radzi sobie z obliczaniem "jasności" koloru. W tym scenariuszu kod próbuje określić, czy nad kolorem należy umieścić biały lub czarny tekst.

Aby dodać to, co inni powiedzieli:

Wszystkie te równania działają całkiem dobrze w praktyce, ale jeśli chcesz być bardzo precyzyjny, musisz najpierw przekonwertować kolor na liniową przestrzeń kolorów( zastosować obraz odwrotny-gamma), zrobić średnią wagę kolorów podstawowych i - jeśli chcesz wyświetlić kolor - przenieś luminancję z powrotem do monitora gamma.

Różnica luminancji pomiędzy wprowadzaniem gamma a wykonywaniem właściwej gamma wynosi do 20% w ciemnych szarościach.

Co ciekawe, Ten sformułowanie dla RGB = > HSV używa tylko v = MAX3 (r,g,b). Innymi słowy, możesz użyć maksimum of (r, g, b) jako V w HSV.

Sprawdziłem i na stronie 575 Hearn & Baker tak też obliczają "wartość".

Rozwiązywałem dziś podobne zadanie w javascript. Zdecydowałem się na tę funkcję getPerceivedLightness(rgb) dla koloru HEX RGB. Dotyczy efektu Helmholtza-Kohlrauscha za pomocą wzoru Fairchilda i Perrotta do korekcji luminancji.

/**
 * Converts RGB color to CIE 1931 XYZ color space.
 * https://www.image-engineering.de/library/technotes/958-how-to-convert-between-srgb-and-ciexyz
 * @param  {string} hex
 * @return {number[]}
 */
export function rgbToXyz(hex) {
    const [r, g, b] = hexToRgb(hex).map(_ => _ / 255).map(sRGBtoLinearRGB)
    const X =  0.4124 * r + 0.3576 * g + 0.1805 * b
    const Y =  0.2126 * r + 0.7152 * g + 0.0722 * b
    const Z =  0.0193 * r + 0.1192 * g + 0.9505 * b
    // For some reason, X, Y and Z are multiplied by 100.
    return [X, Y, Z].map(_ => _ * 100)
}

/**
 * Undoes gamma-correction from an RGB-encoded color.
 * https://en.wikipedia.org/wiki/SRGB#Specification_of_the_transformation
 * https://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color
 * @param  {number}
 * @return {number}
 */
function sRGBtoLinearRGB(color) {
    // Send this function a decimal sRGB gamma encoded color value
    // between 0.0 and 1.0, and it returns a linearized value.
    if (color <= 0.04045) {
        return color / 12.92
    } else {
        return Math.pow((color + 0.055) / 1.055, 2.4)
    }
}

/**
 * Converts hex color to RGB.
 * https://stackoverflow.com/questions/5623838/rgb-to-hex-and-hex-to-rgb
 * @param  {string} hex
 * @return {number[]} [rgb]
 */
function hexToRgb(hex) {
    const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
    if (match) {
        match.shift()
        return match.map(_ => parseInt(_, 16))
    }
}

/**
 * Converts CIE 1931 XYZ colors to CIE L*a*b*.
 * The conversion formula comes from <http://www.easyrgb.com/en/math.php>.
 * https://github.com/cangoektas/xyz-to-lab/blob/master/src/index.js
 * @param   {number[]} color The CIE 1931 XYZ color to convert which refers to
 *                           the D65/2° standard illuminant.
 * @returns {number[]}       The color in the CIE L*a*b* color space.
 */
// X, Y, Z of a "D65" light source.
// "D65" is a standard 6500K Daylight light source.
// https://en.wikipedia.org/wiki/Illuminant_D65
const D65 = [95.047, 100, 108.883]
export function xyzToLab([x, y, z]) {
  [x, y, z] = [x, y, z].map((v, i) => {
    v = v / D65[i]
    return v > 0.008856 ? Math.pow(v, 1 / 3) : v * 7.787 + 16 / 116
  })
  const l = 116 * y - 16
  const a = 500 * (x - y)
  const b = 200 * (y - z)
  return [l, a, b]
}

/**
 * Converts Lab color space to Luminance-Chroma-Hue color space.
 * http://www.brucelindbloom.com/index.html?Eqn_Lab_to_LCH.html
 * @param  {number[]}
 * @return {number[]}
 */
export function labToLch([l, a, b]) {
    const c = Math.sqrt(a * a + b * b)
    const h = abToHue(a, b)
    return [l, c, h]
}

/**
 * Converts a and b of Lab color space to Hue of LCH color space.
 * https://stackoverflow.com/questions/53733379/conversion-of-cielab-to-cielchab-not-yielding-correct-result
 * @param  {number} a
 * @param  {number} b
 * @return {number}
 */
function abToHue(a, b) {
    if (a >= 0 && b === 0) {
        return 0
    }
    if (a < 0 && b === 0) {
        return 180
    }
    if (a === 0 && b > 0) {
        return 90
    }
    if (a === 0 && b < 0) {
        return 270
    }
    let xBias
    if (a > 0 && b > 0) {
        xBias = 0
    } else if (a < 0) {
        xBias = 180
    } else if (a > 0 && b < 0) {
        xBias = 360
    }
    return radiansToDegrees(Math.atan(b / a)) + xBias
}

function radiansToDegrees(radians) {
    return radians * (180 / Math.PI)
}

function degreesToRadians(degrees) {
    return degrees * Math.PI / 180
}

/**
 * Saturated colors appear brighter to human eye.
 * That's called Helmholtz-Kohlrausch effect.
 * Fairchild and Pirrotta came up with a formula to
 * calculate a correction for that effect.
 * "Color Quality of Semiconductor and Conventional Light Sources":
 * https://books.google.ru/books?id=ptDJDQAAQBAJ&pg=PA45&lpg=PA45&dq=fairchild+pirrotta+correction&source=bl&ots=7gXR2MGJs7&sig=ACfU3U3uIHo0ZUdZB_Cz9F9NldKzBix0oQ&hl=ru&sa=X&ved=2ahUKEwi47LGivOvmAhUHEpoKHU_ICkIQ6AEwAXoECAkQAQ#v=onepage&q=fairchild%20pirrotta%20correction&f=false
 * @return {number}
 */
function getLightnessUsingFairchildPirrottaCorrection([l, c, h]) {
    const l_ = 2.5 - 0.025 * l
    const g = 0.116 * Math.abs(Math.sin(degreesToRadians((h - 90) / 2))) + 0.085
    return l + l_ * g * c
}

export function getPerceivedLightness(hex) {
    return getLightnessUsingFairchildPirrottaCorrection(labToLch(xyzToLab(rgbToXyz(hex))))
}

Oto fragment kodu C, który powinien poprawnie obliczyć postrzeganą luminancję.

// reverses the rgb gamma
#define inverseGamma(t) (((t) <= 0.0404482362771076) ? ((t)/12.92) : pow(((t) + 0.055)/1.055, 2.4))

//CIE L*a*b* f function (used to convert XYZ to L*a*b*)  http://en.wikipedia.org/wiki/Lab_color_space
#define LABF(t) ((t >= 8.85645167903563082e-3) ? powf(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))


float
rgbToCIEL(PIXEL p)
{
   float y;
   float r=p.r/255.0;
   float g=p.g/255.0;
   float b=p.b/255.0;

   r=inverseGamma(r);
   g=inverseGamma(g);
   b=inverseGamma(b);

   //Observer = 2°, Illuminant = D65 
   y = 0.2125862307855955516*r + 0.7151703037034108499*g + 0.07220049864333622685*b;

   // At this point we've done RGBtoXYZ now do XYZ to Lab

   // y /= WHITEPOINT_Y; The white point for y in D65 is 1.0

    y = LABF(y);

   /* This is the "normal conversion which produces values scaled to 100
    Lab.L = 116.0*y - 16.0;
   */
   return(1.16*y - 0.16); // return values for 0.0 >=L <=1.0
}

Przestrzeń kolorów HSV powinna wystarczyć, zobacz Artykuł w Wikipedii w zależności od języka, w którym pracujesz, możesz uzyskać konwersję biblioteki .

H to odcień, który jest wartością liczbową dla koloru (np. czerwony, zielony...)

S jest nasyceniem koloru, czyli jak jest "intensywny"

V jest 'jasnością' koloru.

Wartość luminancji RGB = 0,3 R + 0,59 G + 0,11 B

Http://www.scantips.com/lumin.html

Jeśli szukasz jak blisko białego koloru możesz użyć odległości euklidesowej od (255, 255, 255)

Myślę, że przestrzeń kolorów RGB jest postrzegalnie niejednorodna w odniesieniu do odległości euklidesowej L2. Jednolite przestrzenie obejmują CIE LAB I LUV.

Odwrotna formuła gamma przez Jive Dadson musi mieć half-adjust usunięte, gdy zaimplementowane w Javascript, tzn. powrót z funkcji gam_sRGB musi być return int(v*255); nie return int (v*255+.5); Half-adjust rounds up, a to może spowodować zbyt wysoką wartość na R = G=B tj. triadzie koloru szarego. Konwersja skali szarości na triadzie R = G = B powinna dawać wartość równą R; jest to jeden dowód, że formuła jest ważna. Zobacz dziewięć odcieni szarości {[2] } dla formuły w akcji (bez pół-regulacji).

Zastanawiam się jak te współczynniki rgb zostały ustalone. Sam zrobiłem eksperyment i skończyło się na tym, że:

Y = 0.267 R + 0.642 G + 0.091 B

Blisko, ale oczywiście inaczej niż dawno ustalone współczynniki ITU. Zastanawiam się, czy te współczynniki mogą być różne dla każdego obserwatora, ponieważ wszyscy możemy mieć różną ilość stożków i pręcików na siatkówce w naszych oczach, a zwłaszcza stosunek między różnymi typami stożków może się różnić.

Dla odniesienie:

ITU BT.709:

Y = 0.2126 R + 0.7152 G + 0.0722 B

ITU BT.601:

Y = 0.299 R + 0.587 G + 0.114 B

Wykonałem test, szybko przesuwając mały szary pasek na jasnym czerwonym, jasnozielonym i jasnym niebieskim tle i dostosowując szary, aż zmieszał się tak bardzo, jak to możliwe. Powtórzyłem ten test również z innymi odcieniami. Powtórzyłem test na różnych wyświetlaczach, nawet na jednym ze stałym współczynnikiem gamma 3.0, ale dla mnie wszystko wygląda tak samo. Więcej, współczynniki ITU dosłownie są złe dla moich oczu.

" V " HSV jest prawdopodobnie tym, czego szukasz. MATLAB ma funkcję rgb2hsv, a cytowany wcześniej artykuł w Wikipedii jest pełen pseudokod. Jeśli konwersja RGB2HSV nie jest możliwa, mniej dokładnym modelem byłaby wersja obrazu w skali szarości.

Ten link wyjaśnia wszystko dogłębnie, w tym dlaczego te stałe mnożnika istnieją przed wartościami R, G I B.

Edit: ma wyjaśnienie do jednej z odpowiedzi również tutaj (0.299*R + 0.587*G + 0.114*B)

Aby określić jasność koloru za pomocą R, zamieniam kolor systemowy RGB na kolor systemowy HSV.

W moim skrypcie używam wcześniej kodu systemu HEX z innego powodu, ale możesz zacząć również od kodu systemu RGB z rgb2hsv {grDevices}. Dokumentacja jest tutaj.

Oto ta część mojego kodu:

 sample <- c("#010101", "#303030", "#A6A4A4", "#020202", "#010100")
 hsvc <-rgb2hsv(col2rgb(sample)) # convert HEX to HSV
 value <- as.data.frame(hsvc) # create data.frame
 value <- value[3,] # extract the information of brightness
 order(value) # ordrer the color by brightness

Dla jasności, wzory, które używają pierwiastka kwadratowego muszą być

sqrt(coefficient * (colour_value^2))

Nie

sqrt((coefficient * colour_value))^2

Dowodem na to jest konwersja triady R=G=B na skalę szarości R. będzie to prawdą tylko wtedy, gdy ustawisz wartość koloru, a nie współczynnik razy wartości koloru. Zobacz dziewięć odcieni szarości

Proszę zdefiniować jasność. Jeśli szukasz jak blisko białego koloru możesz użyć odległości euklidesowej od (255, 255, 255)