Muszę określić, czy wybrany kolor UIColor (wybrany przez użytkownika) jest ciemny, czy jasny, aby móc zmienić kolor wiersza tekstu, który znajduje się nad tym kolorem, dla lepszej czytelności.

Oto przykład we Flash / Actionscript (z demo): http://web.archive.org/web/20100102024448/http://theflashblog.com/?p=173

jakieś pomysły?

Pozdrawiam, Andre

AKTUALIZACJA

Dzięki sugestiom wszystkich, oto działający kod:

- (void) updateColor:(UIColor *) newColor
{
    const CGFloat *componentColors = CGColorGetComponents(newColor.CGColor);

    CGFloat colorBrightness = ((componentColors[0] * 299) + (componentColors[1] * 587) + (componentColors[2] * 114)) / 1000;
    if (colorBrightness < 0.5)
    {
        NSLog(@"my color is dark");
    }
    else
    {
        NSLog(@"my color is light");
    }
}

Jeszcze raz dziękuję :)

W3C ma następujące elementy: http://www.w3.org/WAI/ER/WD-AERT/#color-contrast

Jeśli robisz tylko czarny lub biały tekst, użyj powyższego obliczenia jasności kolorów. Jeśli jest poniżej 125, użyj białego tekstu. Jeśli jest 125 lub więcej, użyj czarnego tekstu.

edycja 1: odchylenie w kierunku czarnego tekstu. :)

edycja 2: Formuła do użycia to ((wartość czerwona * 299) + (wartość zielona * 587) + (wartość niebieska * 114)) / 1000.

Oto rozszerzenie Swift (3) umożliwiające wykonanie tego sprawdzenia.

To rozszerzenie działa z kolorami w skali szarości. Jeśli jednak tworzysz wszystkie kolory za pomocą inicjatora RGB i nie używasz wbudowanych kolorów, takich jak UIColor.blacki UIColor.white, prawdopodobnie możesz usunąć dodatkowe kontrole.

extension UIColor {

    // Check if the color is light or dark, as defined by the injected lightness threshold.
    // Some people report that 0.7 is best. I suggest to find out for yourself.
    // A nil value is returned if the lightness couldn't be determined.
    func isLight(threshold: Float = 0.5) -> Bool? {
        let originalCGColor = self.cgColor

        // Now we need to convert it to the RGB colorspace. UIColor.white / UIColor.black are greyscale and not RGB.
        // If you don't do this then you will crash when accessing components index 2 below when evaluating greyscale colors.
        let RGBCGColor = originalCGColor.converted(to: CGColorSpaceCreateDeviceRGB(), intent: .defaultIntent, options: nil)
        guard let components = RGBCGColor?.components else {
            return nil
        }
        guard components.count >= 3 else {
            return nil
        }

        let brightness = Float(((components[0] * 299) + (components[1] * 587) + (components[2] * 114)) / 1000)
        return (brightness > threshold)
    }
}

Testy:

func testItWorks() {
    XCTAssertTrue(UIColor.yellow.isLight()!, "Yellow is LIGHT")
    XCTAssertFalse(UIColor.black.isLight()!, "Black is DARK")
    XCTAssertTrue(UIColor.white.isLight()!, "White is LIGHT")
    XCTAssertFalse(UIColor.red.isLight()!, "Red is DARK")
}

Uwaga: zaktualizowano do wersji Swift 3 12/7/18

Korzystając z odpowiedzi Erika Nedwidka, wymyśliłem mały fragment kodu do łatwego włączenia.

- (UIColor *)readableForegroundColorForBackgroundColor:(UIColor*)backgroundColor {
    size_t count = CGColorGetNumberOfComponents(backgroundColor.CGColor);
    const CGFloat *componentColors = CGColorGetComponents(backgroundColor.CGColor);

    CGFloat darknessScore = 0;
    if (count == 2) {
        darknessScore = (((componentColors[0]*255) * 299) + ((componentColors[0]*255) * 587) + ((componentColors[0]*255) * 114)) / 1000;
    } else if (count == 4) {
        darknessScore = (((componentColors[0]*255) * 299) + ((componentColors[1]*255) * 587) + ((componentColors[2]*255) * 114)) / 1000;
    }

    if (darknessScore >= 125) {
        return [UIColor blackColor];
    }

    return [UIColor whiteColor];
}

Swift3

extension UIColor {
    var isLight: Bool {
        var white: CGFloat = 0
        getWhite(&white, alpha: nil)
        return white > 0.5
    }
}

// Usage
if color.isLight {
    label.textColor = UIColor.black
} else {
    label.textColor = UIColor.white
}

Wersja Swift 4

extension UIColor {
    func isLight() -> Bool {
        guard let components = cgColor.components, components.count > 2 else {return false}
        let brightness = ((components[0] * 299) + (components[1] * 587) + (components[2] * 114)) / 1000
        return (brightness > 0.5)
    }
}

Moje rozwiązanie tego problemu w kategorii (zaczerpnięte z innych odpowiedzi tutaj). Działa również z kolorami w skali szarości, których w chwili pisania tego tekstu żadna z pozostałych odpowiedzi nie działa.

@interface UIColor (Ext)

    - (BOOL) colorIsLight;

@end

@implementation UIColor (Ext)

    - (BOOL) colorIsLight {
        CGFloat colorBrightness = 0;

        CGColorSpaceRef colorSpace = CGColorGetColorSpace(self.CGColor);
        CGColorSpaceModel colorSpaceModel = CGColorSpaceGetModel(colorSpace);

        if(colorSpaceModel == kCGColorSpaceModelRGB){
            const CGFloat *componentColors = CGColorGetComponents(self.CGColor);

            colorBrightness = ((componentColors[0] * 299) + (componentColors[1] * 587) + (componentColors[2] * 114)) / 1000;
        } else {
            [self getWhite:&colorBrightness alpha:0];
        }

        return (colorBrightness >= .5f);
    }

@end

Prostsze rozszerzenie Swift 3:

extension UIColor {
    func isLight() -> Bool {
        guard let components = cgColor.components else { return false }
        let redBrightness = components[0] * 299
        let greenBrightness = components[1] * 587
        let blueBrightness = components[2] * 114
        let brightness = (redBrightness + greenBrightness + blueBrightness) / 1000
        return brightness > 0.5
    }
}

Jeśli wolisz wersję blokową:

BOOL (^isDark)(UIColor *) = ^(UIColor *color){
    const CGFloat *component = CGColorGetComponents(color.CGColor);
    CGFloat brightness = ((component[0] * 299) + (component[1] * 587) + (component[2] * 114)) / 1000;

    if (brightness < 0.75)
        return  YES;
    return NO;
};

W przypadku wszystkiego, co nie jest szare, odwrotność RGB koloru jest zwykle silnie z nim kontrastowana. Demo po prostu odwraca kolor i usuwa jego nasycenie (zamienia go na szary).

Ale stworzenie ładnej kojącej kombinacji kolorów jest dość skomplikowane. Patrzeć na :

http://particletree.com/notebook/calculating-color-contrast-for-legible-text/

Następująca metoda polega na znalezieniu koloru jako jasnego lub ciemnego w języku Swift w oparciu o kolor biały.

func isLightColor(color: UIColor) -> Bool 
{
   var white: CGFloat = 0.0
   color.getWhite(&white, alpha: nil)

   var isLight = false

   if white >= 0.5
   {
       isLight = true
       NSLog("color is light: %f", white)
   }
   else
   {
      NSLog("Color is dark: %f", white)
   }

   return isLight
}

Następująca metoda polega na znalezieniu koloru jako jasnego lub ciemnego w języku Swift przy użyciu składników koloru.

func isLightColor(color: UIColor) -> Bool 
{
     var isLight = false

     var componentColors = CGColorGetComponents(color.CGColor)

     var colorBrightness: CGFloat = ((componentColors[0] * 299) + (componentColors[1] * 587) + (componentColors[2] * 114)) / 1000;
     if (colorBrightness >= 0.5)
     {
        isLight = true
        NSLog("my color is light")
     }
     else
     {
        NSLog("my color is dark")
     }  
     return isLight
}

Dla mnie używanie tylko CGColorGetComponents nie zadziałało, otrzymuję 2 komponenty dla UIColors, takie jak biały. Muszę więc najpierw sprawdzić model przestrzeni kolorów. Oto, co wymyśliłem, i okazało się, że jest to szybka wersja odpowiedzi @ mattsven.

Przestrzeń kolorów pobrana stąd: https://stackoverflow.com/a/16981916/4905076

extension UIColor {
    func isLight() -> Bool {
        if let colorSpace = self.cgColor.colorSpace {
            if colorSpace.model == .rgb {
                guard let components = cgColor.components, components.count > 2 else {return false}

                let brightness = ((components[0] * 299) + (components[1] * 587) + (components[2] * 114)) / 1000

                return (brightness > 0.5)
            }
            else {
                var white : CGFloat = 0.0

                self.getWhite(&white, alpha: nil)

                return white >= 0.5
            }
        }

        return false
    }

UIColor ma następującą metodę konwersji na przestrzeń kolorów HSB :

- (BOOL)getHue:(CGFloat *)hue saturation:(CGFloat *)saturation brightness:(CGFloat *)brightness alpha:(CGFloat *)alpha;

- (BOOL)isColorLight:(UIColor*)color
{
    CGFloat white = 0;
    [color getWhite:&white alpha:nil];
    return (white >= .85);
}

Dodana Swift 5wersja:

var white: CGFloat = 0.0
color.getWhite(&white, alpha: nil)
return white >= .85 // Don't use white background

Jeśli chcesz znaleźć jasność koloru, oto pseudo kod:

public float GetBrightness(int red, int blue, int green)
{
    float num = red / 255f;
    float num2 = blue / 255f;
    float num3 = green / 255f;
    float num4 = num;
    float num5 = num;
    if (num2 > num4)
        num4 = num2;
    if (num3 > num4)
        num4 = num3;
    if (num2 < num5)
        num5 = num2;
    if (num3 < num5)
        num5 = num3;
    return ((num4 + num5) / 2f);
}

Jeśli jest> 0,5, oznacza to, że jest jasne, a poza tym ciemne.