Ich muss feststellen, ob eine ausgewählte UIColor (vom Benutzer ausgewählt) dunkel oder hell ist, damit ich die Farbe einer Textzeile ändern kann, die über dieser Farbe liegt, um die Lesbarkeit zu verbessern.

Hier ist ein Beispiel in Flash / Actionscript (mit Demo): http://web.archive.org/web/20100102024448/http://theflashblog.com/?p=173

Irgendwelche Gedanken?

Prost, Andre

AKTUALISIEREN

Dank aller Vorschläge ist hier der Arbeitscode:

- (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");
    }
}

Noch einmal vielen Dank :)

W3C hat Folgendes: http://www.w3.org/WAI/ER/WD-AERT/#color-contrast

Wenn Sie nur schwarzen oder weißen Text erstellen, verwenden Sie die obige Berechnung der Farbhelligkeit. Wenn es unter 125 liegt, verwenden Sie weißen Text. Wenn es 125 oder höher ist, verwenden Sie schwarzen Text.

edit 1: Neigung zu schwarzem Text. :) :)

Bearbeiten 2: Die zu verwendende Formel lautet ((roter Wert * 299) + (grüner Wert * 587) + (blauer Wert * 114)) / 1000.

Hier ist eine Swift (3) -Erweiterung, um diese Prüfung durchzuführen.

Diese Erweiterung funktioniert mit Graustufenfarben. Wenn Sie jedoch alle Ihre Farben mit dem RGB - initializer schaffen und nicht die eingebauten Farben wie die Verwendung UIColor.blackund UIColor.white, dann können Sie möglicherweise die zusätzlichen Prüfungen entfernen.

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

Tests:

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")
}

Hinweis: Aktualisiert auf Swift 3 07.12.18

Mit der Antwort von Erik Nedwidek habe ich mir diesen kleinen Codeausschnitt ausgedacht, um ihn einfach einbinden zu können.

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

Swift 4 Version

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

Meine Lösung für dieses Problem in einer Kategorie (aus anderen Antworten hier). Funktioniert auch mit Graustufenfarben, was zum Zeitpunkt des Schreibens keine der anderen Antworten tut.

@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

Einfachere Swift 3-Erweiterung:

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

Wenn Sie die Blockversion bevorzugen:

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

Für alles, was nicht grau ist, wird die RGB-Umkehrung einer Farbe normalerweise stark kontrastiert. Die Demo invertiert nur die Farbe und entsättigt sie (konvertiert sie in ein Grau).

Das Erzeugen einer schönen beruhigenden Farbkombination ist jedoch ziemlich kompliziert. Ansehen :

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

Die folgende Methode lautet: Finden Sie, dass die Farbe in der Swift-Sprache hell oder dunkel ist, basierend auf der weißen Farbe.

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
}

Die folgende Methode besteht darin, mithilfe von Farbkomponenten zu ermitteln, ob die Farbe in Swift hell oder dunkel ist.

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
}

Für mich hat es nicht funktioniert, nur CGColorGetComponents zu verwenden. Ich bekomme 2 Komponenten für UIColors wie Weiß. Also muss ich zuerst das color spaceModel überprüfen. Dies ist, was ich mir ausgedacht habe, was die schnelle Version von @ mattsvens Antwort war.

Farbraum von hier genommen: 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 verfügt über die folgende Methode zum Konvertieren in den HSB-Farbraum :

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

Hinzugefügte Swift 5Version:

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

Wenn Sie die Helligkeit der Farbe ermitteln möchten, finden Sie hier einen Pseudocode:

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

Wenn es> 0,5 ist, ist es hell und ansonsten dunkel.