Jak porównać kolory UIColors?

128

Chciałbym sprawdzić zestaw kolorów dla tła w UIImageView. Próbowałem:

if(myimage.backgroundColor == [UIColor greenColor]){
...}
else{
...}

ale to nie działa, nawet jeśli wiem, że kolor jest zielony, zawsze wpada w inną część.

Czy istnieje również sposób na wyświetlenie bieżącego koloru w konsoli debugowania.

p [myimage backgroundColor]

i

po [myimage backgroundColor]

nie działa.

4thSpace
źródło

Odpowiedzi:

175

Czy próbowałeś [myColor isEqual:someOtherColor]?

Steven Canfield
źródło
Dzięki. Jaka jest różnica z isEqualTo? Czy wiesz również, jak wyświetlić go w debugerze?
4thSpace
95
Przy okazji: zachowaj ostrożność podczas porównywania kolorów w ten sposób, ponieważ muszą one być w tym samym modelu kolorów, aby można je było uznać za równe. Na przykład # ffffffnie jest równe [UIColor whiteColor].
zoul
2
Słuszna uwaga Zoul, może być bardziej przydatne wskazanie rozwiązania, a nie tylko problemu = D
pfrank
11
Słuszna uwaga Pfrank, może być bardziej przydatne wskazanie rozwiązania, a nie tylko problemu = D
Albert Renshaw
Nie zawsze mi się to udawało, porównując button.tintColor z kolorem, na który go ustawiłem. Miał związek z zaokrąglaniem. Jeśli napotkasz to, zobacz moją odpowiedź poniżej.
Pbk,
77

Jak zauważył Zoul w komentarzach, isEqual:powróci NOpodczas porównywania kolorów, które są w różnych modelach / przestrzeniach (na przykład #FFFz [UIColor whiteColor]). Napisałem to rozszerzenie UIColor, które konwertuje oba kolory na tę samą przestrzeń kolorów przed ich porównaniem:

- (BOOL)isEqualToColor:(UIColor *)otherColor {
    CGColorSpaceRef colorSpaceRGB = CGColorSpaceCreateDeviceRGB();

    UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color) {
        if (CGColorSpaceGetModel(CGColorGetColorSpace(color.CGColor)) == kCGColorSpaceModelMonochrome) {
            const CGFloat *oldComponents = CGColorGetComponents(color.CGColor);
            CGFloat components[4] = {oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]};
            CGColorRef colorRef = CGColorCreate( colorSpaceRGB, components );

            UIColor *color = [UIColor colorWithCGColor:colorRef];
            CGColorRelease(colorRef);
            return color;            
        } else
            return color;
    };

    UIColor *selfColor = convertColorToRGBSpace(self);
    otherColor = convertColorToRGBSpace(otherColor);
    CGColorSpaceRelease(colorSpaceRGB);

    return [selfColor isEqual:otherColor];
}
samvermette
źródło
2
Fajnie, ale chyba jest przeciek. Nigdy nie zwalniasz CGColorCreate w środku.
borrrden
To idealne rozwiązanie!
alones
Czy możesz wyjaśnić, co się dzieje z karatami? Chyba nie widziałem wcześniej tej składni.
Victor Engel,
@VictorEngel, UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color) ...deklaruje plik block. Używa go później z convertColorToRGBSpace(self). Aby zapoznać się z wprowadzeniem do bloków w iOS, zobacz raywenderlich.com/9328/creating-a-diner-app-using-blocks-part-1
JRG-Developer,
1
Używam wszystkich bloków, ale nigdy wcześniej nie widziałem takiej składni. Chyba nie użyłem bloku, który zwrócił obiekt. To jest to, co jest po lewej stronie =, o którym pisałem.
Victor Engel,
65

To może być trochę za późno, ale CoreGraphics ma łatwiejszy interfejs API, aby to osiągnąć:

CGColorEqualToColor(myColor.CGColor, [UIColor clearColor].CGColor)

Jak mówi dokumentacja:

Wskazuje, czy dwa kolory są równe. Dwa kolory są równe, jeśli mają równe przestrzenie kolorów i liczbowo równe składniki kolorów.

To rozwiązuje wiele problemów i nieszczelnych / niestandardowych algorytmów.

DZenBot
źródło
5
[UIColor isEqual:]robi to samo, prawda? Odpowiedź Marka jest nadal jedyną, która sprawdza równoważność pomimo dobrej przestrzeni kolorów.
mattsven
9
To nie pomaga bardziej, niż UIColor isEqual:gdyby kolory były w różnych przestrzeniach kolorów.
Echelon
Pytanie dotyczy porównania UIColor, a nie porównania CGColor.
Sean Vikoren
Dokładniejsze niż wszystkie inne rozwiązania :) +1 ode mnie
Nirav Gadhiya
8

rozwiązanie samvermette przetłumaczone na szybkie:

extension UIColor {
    func isEqualToColor(otherColor : UIColor) -> Bool {
        if self == otherColor {
            return true
        }

        let colorSpaceRGB = CGColorSpaceCreateDeviceRGB()
        let convertColorToRGBSpace : ((color : UIColor) -> UIColor?) = { (color) -> UIColor? in
            if CGColorSpaceGetModel(CGColorGetColorSpace(color.CGColor)) == CGColorSpaceModel.Monochrome {
                let oldComponents = CGColorGetComponents(color.CGColor)
                let components : [CGFloat] = [ oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1] ]
                let colorRef = CGColorCreate(colorSpaceRGB, components)
                let colorOut = UIColor(CGColor: colorRef!)
                return colorOut
            }
            else {
                return color;
            }
        }

        let selfColor = convertColorToRGBSpace(color: self)
        let otherColor = convertColorToRGBSpace(color: otherColor)

        if let selfColor = selfColor, otherColor = otherColor {
            return selfColor.isEqual(otherColor)
        }
        else {
            return false
        }
    }
}
raf
źródło
7
#import "UIColor-Expanded.h"
//https://github.com/thetaplab/uicolor-utilities

//RGB distance
CGFloat distance = sqrtf(powf((clr0.red - clr1.red), 2) + powf((clr0.green - clr1.green), 2) + powf((clr0.blue - clr1.blue), 2) );
if(distance<=minDistance){
....
}else{
...
}
Viktor Goltvyanitsa
źródło
@Rudolf Adamkovic, to twierdzenie Pitagorasa
Viktor Goltvyanitsa
6

To rozszerzenie UIColor działa dobrze, pod warunkiem, że porównywane kolory można przekonwertować na format RGB, co powinno być w większości przypadków.

public extension UIColor {

    static func == (l: UIColor, r: UIColor) -> Bool {
        var l_red = CGFloat(0); var l_green = CGFloat(0); var l_blue = CGFloat(0); var l_alpha = CGFloat(0)
        guard l.getRed(&l_red, green: &l_green, blue: &l_blue, alpha: &l_alpha) else { return false }
        var r_red = CGFloat(0); var r_green = CGFloat(0); var r_blue = CGFloat(0); var r_alpha = CGFloat(0)
        guard r.getRed(&r_red, green: &r_green, blue: &r_blue, alpha: &r_alpha) else { return false }
        return l_red == r_red && l_green == r_green && l_blue == r_blue && l_alpha == r_alpha
    }
}

Przynajmniej z tym rozszerzeniem:

UIColor.whiteColor == UIColor(hex: "#FFFFFF") // true
UIColor.black == UIColor(red: 0, green: 0, blue: 0, alpha: 1) // true

Oba porównania zwróciłyby fałsz, gdyby porównać je przy użyciu natywnego UColor.isEqual (...)

boherna
źródło
5

Napisałem tę kategorię. Jeśli isEqual:zwróci NIE, sprawdzi, czy dalsze porównanie różnych składników może nadal pasować. Jeśli to możliwe, nadal porównuje się różne modele.

@implementation UIColor (Matching)


-(BOOL)matchesColor:(UIColor *)color error:(NSError *__autoreleasing *)error
{
    UIColor *lhs = self;
    UIColor *rhs = color;

    if([lhs isEqual:rhs]){ // color model and values are the same
        return YES;
    }

    CGFloat red1, red2, green1, alpha1, green2, blue1, blue2, alpha2;
    BOOL lhsSuccess = [lhs getRed:&red1 green:&green1 blue:&blue1 alpha:&alpha1];
    BOOL rhsSuccess = [rhs getRed:&red2 green:&green2 blue:&blue2 alpha:&alpha2];
    if((!lhsSuccess && rhsSuccess) || (lhsSuccess && !rhsSuccess)){ // one is RGBA, one color not.
        CGFloat r,g,b,a;
        if(!lhsSuccess){ // lhs color could be a monochrome
            const CGFloat *components = CGColorGetComponents(lhs.CGColor);
            if([lhs _colorSpaceModel] == kCGColorSpaceModelMonochrome){
                r = g = b = components[0];
                a = components[1];

                return r == red2 && g == green2 && b == blue2 && a == alpha2;
            }
        } else {  // rhs color could be a monochrome
            const CGFloat *components = CGColorGetComponents(rhs.CGColor);

            if([rhs _colorSpaceModel] == kCGColorSpaceModelMonochrome){
                r = g = b = components[0];
                a = components[1];
                return r == red1 && g == green1 && b == blue1 && a == alpha1;
            }
        }


        NSError *aError = [[NSError alloc] initWithDomain:@"UIColorComparision" code:-11111 userInfo:[self _colorComparisionErrorUserInfo]];
        *error = aError;
        return  NO;
    } else if (!lhsSuccess && !rhsSuccess){ // both not RGBA, lets try HSBA
        CGFloat hue1,saturation1,brightness1;
        CGFloat hue2,saturation2,brightness2;

        lhsSuccess = [lhs getHue:&hue1 saturation:&saturation1 brightness:&brightness1 alpha:&alpha1];
        rhsSuccess = [lhs getHue:&hue2 saturation:&saturation2 brightness:&brightness2 alpha:&alpha2];
        if((!lhsSuccess && rhsSuccess) || (lhsSuccess && !rhsSuccess)){
            NSError *aError = [[NSError alloc] initWithDomain:@"UIColorComparision" code:-11111 userInfo:[self _colorComparisionErrorUserInfo]];
            *error = aError;
            return  NO;
        } else if(!lhsSuccess && !rhsSuccess){ // both not HSBA, lets try monochrome
            CGFloat white1, white2;

            lhsSuccess = [lhs getWhite:&white1 alpha:&alpha1];
            rhsSuccess = [rhs getWhite:&white2 alpha:&alpha2];
            if((!lhsSuccess && rhsSuccess) || (lhsSuccess && !rhsSuccess)){
                NSError *aError = [[NSError alloc] initWithDomain:@"UIColorComparision" code:-11111 userInfo:[self _colorComparisionErrorUserInfo]];
                *error = aError;
                return  NO;
            } else {
                return white1 == white2 && alpha1 == alpha2;
            }

        } else {
            return hue1 == hue2 && saturation1 == saturation2 && brightness1 == brightness2 && alpha1 == alpha2;
        }

    } else {
        return (red1 == red2 && green1 == green2 && blue1 == blue2 && alpha1 == alpha2);

    }
}

-(NSDictionary *)_colorComparisionErrorUserInfo{

    NSDictionary *userInfo = @{
                               NSLocalizedDescriptionKey: NSLocalizedString(@"Comparision failed.", nil),
                               NSLocalizedFailureReasonErrorKey: NSLocalizedString(@"The colors models are incompatible. Or the color is a pattern.", nil),

                               };
    return userInfo;
}

- (CGColorSpaceModel)_colorSpaceModel {
    return CGColorSpaceGetModel(CGColorGetColorSpace(self.CGColor));
}

@end

UIColor *green1 = [UIColor greenColor];
UIColor *green2 = [UIColor colorWithRed:0 green:1 blue:0 alpha:1];
UIColor *yellow = [UIColor yellowColor];
UIColor *grey1  = [UIColor colorWithWhite:2.0/3.0 alpha:1];
UIColor *grey2  = [UIColor lightGrayColor];

NSError *error1, *error2, *error3, *error4, *error5;

BOOL match1 = [green1 matchesColor:green2 error:&error1];   // YES
BOOL match2 = [green1 matchesColor:yellow error:&error2];   // NO
BOOL match3 = [green1 matchesColor:grey1 error:&error3];    // NO
BOOL match4 = [grey1 matchesColor:grey2 error:&error4];     // YES
BOOL match5 = [grey1 matchesColor:[UIColor colorWithPatternImage:[UIImage imageNamed:@"bg.png"]]
                            error:&error5];                 // NO, Error
vikingosegundo
źródło
2

Kiedy porównujesz w myimage.backgroundColor == [UIColor greenColor]ten sposób, jeśli nie zmieniłeś koloru backgroundColor na zielony przed tym stwierdzeniem, nie działa.

Miałem ten sam problem w mojej grze w kolory i rozwiązałem to używając prostego równania różnicowego w kolorach RGB, możesz szybko rzucić okiem na ten krótki kod ColorProcess stąd

to jak odpowiedź zwycięzców

GFloat distance = sqrtf(powf((clr0.red - clr1.red), 2) + powf((clr0.green - clr1.green), 2) + powf((clr0.blue - clr1.blue), 2) );
if(distance<=minDistance){
....
}else{
…
}

Zamiast tego przykładowego kodu możesz użyć

include "UIColorProcess.h"

..

float distance = [UIColorProcess findDistanceBetweenTwoColor:[UIColor redColor] secondColor:[UIColor blueColor]];

i oczywiście jeśli zwraca 0, oznacza to, że porównujesz zbyt podobny kolor. zakres zwrotny jest mniej więcej taki jak (0,0f - 1,5f).

mert
źródło
color.red/blue/green nie są obsługiwane dla wszystkich różnych typów klas kolorów, sprawdź dokumentację
pfrank
1

Mogą wystąpić dziwne błędy zaokrągleń. Może to być powód, dla którego obiekt został ustawiony na kolor, a kolor, który ustawiłeś, nie pasuje dokładnie.

Oto jak to rozwiązałem:

private func compareColors (c1:UIColor, c2:UIColor) -> Bool{
    // some kind of weird rounding made the colors unequal so had to compare like this

    var red:CGFloat = 0
    var green:CGFloat  = 0
    var blue:CGFloat = 0
    var alpha:CGFloat  = 0
    c1.getRed(&red, green: &green, blue: &blue, alpha: &alpha)

    var red2:CGFloat = 0
    var green2:CGFloat  = 0
    var blue2:CGFloat = 0
    var alpha2:CGFloat  = 0
    c2.getRed(&red2, green: &green2, blue: &blue2, alpha: &alpha2)

    return (Int(green*255) == Int(green2*255))

}

Ten kod można ulepszyć nie tylko porównując 1, ale porównując wszystkie komponenty. Np. Czerwony + zielony + niebieski + alpha == red2 + green2 + blue2 + alpha2

Pbk
źródło
1
Kolory nie są takie same w porównaniu tylko z zielonym komponentem
pronebird
Jest to jedyna odpowiedź, która wymienia i próbuje rozwiązać potencjalne błędy zaokrągleń, które mogą pojawić się podczas porównywania kolorów ustawianych za pomocą różnych środków; Tak więc, chociaż skupia się tylko na zielonym, przykład (jak wspomina autor odpowiedzi) można uogólnić. W związku z tym, a ponieważ zaokrąglanie było w rzeczywistości problemem, na który się natknąłem, uznałem tę odpowiedź za pomocną.
Matt Wagner
1

Używam tego rozszerzenia, które działa dla mnie we wszystkich przypadkach.

/***** UIColor Extension to Compare colors as string *****/
@interface UIColor (compare)
- (BOOL)compareWithColor:(UIColor *)color;
@end

@implementation UIColor(compare)
- (BOOL)compareWithColor:(UIColor *)color {
    return ([[[CIColor colorWithCGColor:self.CGColor] stringRepresentation] isEqualToString:[[CIColor colorWithCGColor:color.CGColor] stringRepresentation]]);
}
@end
/**** End ****/

Nadzieja komuś pomaga.

Uwaga: #ffffffrówna się [UIColor whiteColor]przez to rozszerzenie

arunit21
źródło
Czy to działa podczas porównywania kolorów w przestrzeniach kolorów?
Kartick Vaddadi
Nie jestem pewien, nie testowałem tego dla wszystkich przestrzeni kolorów.
arunit21
0

Co powiesz na:

+(BOOL)color:(UIColor *)color1 matchesColor:(UIColor *)color2
{
    CGFloat red1, red2, green1, green2, blue1, blue2, alpha1, alpha2;
    [color1 getRed:&red1 green:&green1 blue:&blue1 alpha:&alpha1];
    [color2 getRed:&red2 green:&green2 blue:&blue2 alpha:&alpha2];

    return (red1 == red2 && green1 == green2 && blue1 == blue2 && alpha1 == alpha2);
}
dooleyo
źródło
może to nie działać w przypadku skrajnych przypadków jako kolor wzoru. from doc Jeśli kolor jest w zgodnej przestrzeni kolorów, kolor jest konwertowany do formatu RGB, a jego składniki są zwracane do aplikacji. Jeśli kolor nie znajduje się w zgodnej przestrzeni kolorów, parametry pozostają niezmienione. Więc możesz utworzyć instancję każdego float za pomocą, -1a jeśli któryś z nich nadal ma tę wartość po wywołaniu getRed:green:blue:alpha:, wiesz, że porównanie nie powiodło się. (lub nie pomijaj zwróconej wartości logicznej, ponieważ powie ci, czy została pomyślnie wywołana.)
vikingosegundo
1
Właśnie sprawdziłem: chociaż teoretycznie można porównać monochromatyczne z kolorami RGBA, to nie zadziała z twoim kodem, ponieważ getRed:free:blue:alpha:nie powiedzie się na monochromatycznym kolorze. Więc twój kod nie da innego wyniku niż is equal:. zobacz moją odpowiedź, jak sobie z tym poradzić.
vikingosegundo
+1 za dokładność! Powyższy kod działa w moim prostym przypadku, ale wygląda na to, że nie jest to srebrny nabój. Dobry towar.
dooleyo
0

Oto rozszerzenie umożliwiające przejście do RGC Space Color w Swift:

extension UIColor {

func convertColorToRGBSpaceColor() -> UIColor {
    let colorSpaceRGB = CGColorSpaceCreateDeviceRGB()
    let oldComponents = CGColorGetComponents(self.CGColor)
    let components = [oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]]
    let colorRef = CGColorCreate(colorSpaceRGB, components)
    let convertedColor = UIColor(CGColor: colorRef!)
    return convertedColor
}

}

RyanPliske
źródło
0

Rozszerzenie do UIColor przy użyciu funkcji Swift 2.2. Zwróć jednak uwagę, że ponieważ wartości RGBA są porównywane, a są to CGFloat, błędy zaokrąglania mogą spowodować, że kolory nie są zwracane jako równe, jeśli nie są dokładnie takie same (np. Nie zostały pierwotnie utworzone przy użyciu tych samych właściwości w init (...)!).

/**
 Extracts the RGBA values of the colors and check if the are the same.
 */

public func isEqualToColorRGBA(color : UIColor) -> Bool {
    //local type used for holding converted color values
    typealias colorType = (red : CGFloat, green : CGFloat, blue : CGFloat, alpha : CGFloat)
    var myColor         : colorType = (0,0,0,0)
    var otherColor      : colorType = (0,0,0,0)
    //getRed returns true if color could be converted so if one of them failed we assume that colors are not equal
    guard getRed(&myColor.red, green: &myColor.green, blue: &myColor.blue, alpha: &myColor.alpha) &&
        color.getRed(&otherColor.red, green: &otherColor.green, blue: &otherColor.blue, alpha: &otherColor.alpha)
        else {
            return false
    }
    log.debug("\(myColor) = \(otherColor)")
    //as of Swift 2.2 (Xcode 7.3.1), tuples up to arity 6 can be compared with == so this works nicely
    return myColor == otherColor
}
HixField
źródło
0

Rozszerzenie UIColor

- (CGFloat)accuracyCompareWith:(UIColor *)color {
    CIColor *c1 = [[CIColor alloc] initWithColor:self];
    CIColor *c2 = [[CIColor alloc] initWithColor:color];

    BOOL hasAlpha = c1.numberOfComponents == 4 && c2.numberOfComponents == 4;
    NSInteger numberOfComponents = hasAlpha ? 4 : 3;

    CGFloat colorMax = 1.0;
    CGFloat p = colorMax / 100.0;

    CGFloat redP = fabs(c1.red / p - c2.red / p);
    CGFloat greenP = fabs(c1.green / p - c2.green / p);
    CGFloat blueP = fabs(c1.blue / p - c2.blue / p);
    CGFloat alphaP = 0;

    if (hasAlpha)
        alphaP = fabs(c1.alpha / p - c2.alpha / p);

    return (redP + greenP + blueP + alphaP) / (CGFloat)numberOfComponents;
}
uranpro
źródło
0

Mam przeliczone odpowiedź RAF do Swift 4 (wiele zmian w CGColorAPI) usuniętego siły odpakowanie i zmniejszyła wcięcia dzięki hojnym wykorzystania guard:

@extension UIColor {
    func isEqualToColor(otherColor: UIColor) -> Bool {
        if self == otherColor {
            return true
        }
        let colorSpaceRGB = CGColorSpaceCreateDeviceRGB()
        let convertColorToRGBSpace: ((UIColor) -> UIColor?) = { (color) -> UIColor? in
            guard color.cgColor.colorSpace?.model == .monochrome else {
                return color
            }
            guard let oldComponents = color.cgColor.components else {
                return nil
            }
            let newComponents = [oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]]
            guard let colorRef = CGColor(colorSpace: colorSpaceRGB, components: newComponents) else {
                    return nil
            }
            return UIColor(cgColor: colorRef)
        } 

        guard let selfColor = convertColorToRGBSpace(self), 
              let otherColor = convertColorToRGBSpace(otherColor) else {
            return false
        }
        return selfColor.isEqual(otherColor)
    }
}
Nicolas Miari
źródło
0

Dlaczego nie dodać rozszerzenia z równoważnym protokołem? Ta odpowiedź wykorzystuje rozwiązanie Nicolasa Miari. Jeśli więc podoba Ci się ta odpowiedź, zapraszam do polubienia jego odpowiedzi (druga od góry)

Komentarz Zoula: Zachowaj ostrożność podczas porównywania kolorów w ten sposób, ponieważ muszą one być w tym samym modelu kolorów, aby można je było uznać za równe. Na przykład #ffffff nie równa się [UIColor whiteColor]

static func == (lhs: UIColor, rhs: UIColor) -> Bool {

    let colorSpaceRGB = CGColorSpaceCreateDeviceRGB()
    let convertColorToRGBSpace: ((UIColor) -> UIColor?) = { (color) -> UIColor? in
        guard color.cgColor.colorSpace?.model == .monochrome else {
            return color
        }
        guard let oldComponents = color.cgColor.components else {
            return nil
        }
        let newComponents = [oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]]
        guard let colorRef = CGColor(colorSpace: colorSpaceRGB, components: newComponents) else {
            return nil
        }
        return UIColor(cgColor: colorRef)
    }

    guard let selfColor = convertColorToRGBSpace(lhs),
        let otherColor = convertColorToRGBSpace(rhs) else {
            return false
    }
    return selfColor.isEqual(otherColor)
}
Illya Krit
źródło
0

Chociaż odpowiedź @ samvermette jest bardzo dobra, odkryłem, że czasami może to prowadzić do fałszywych negatywów podczas porównywania różnych typów kolorów (w moim przypadku UIDeviceRGBColordo UICachedDeviceWhiteColor). Naprawiłem to, jawnie tworząc kolor w elemencie „else”:

- (BOOL)isEqualToColor:(UIColor *)otherColor
{
    if (self == otherColor)
        return YES;

    CGColorSpaceRef colorSpaceRGB = CGColorSpaceCreateDeviceRGB();

    UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color)
    {
        if (CGColorSpaceGetModel(CGColorGetColorSpace(color.CGColor)) == kCGColorSpaceModelMonochrome)
        {
            const CGFloat *oldComponents = CGColorGetComponents(color.CGColor);
            CGFloat components[4] = {oldComponents[0], oldComponents[0], oldComponents[0], oldComponents[1]};
            CGColorRef colorRef = CGColorCreate(colorSpaceRGB, components);
            UIColor *color = [UIColor colorWithCGColor:colorRef];
            CGColorRelease(colorRef);
            return color;
        }
        else
        {
            const CGFloat *oldComponents = CGColorGetComponents(color.CGColor);
            CGFloat components[4] = {oldComponents[0], oldComponents[1], oldComponents[2], oldComponents[3]};
            CGColorRef colorRef = CGColorCreate(colorSpaceRGB, components);
            UIColor *color = [UIColor colorWithCGColor:colorRef];
            CGColorRelease(colorRef);
            return color;
        }
    };

    UIColor *selfColor = convertColorToRGBSpace(self);
    otherColor = convertColorToRGBSpace(otherColor);
    CGColorSpaceRelease(colorSpaceRGB);

    return [selfColor isEqual:otherColor];
}
TOPÓR
źródło
0

Musisz użyć

BOOL equalColors = CGColorEqualToColor(uiColor1.CGColor, uiColor2.CGColor));

Dokumentacja tutaj .

Matteo Gobbi
źródło
0

Przeczytałem i wypróbowałem wszystkie odpowiedzi na tej stronie, myślę, że boheras jest najlepszy, dopracowałem go i oto jest:

extension UIColor {
var rgba: (red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat) {
    var red = CGFloat.zero
    var green = CGFloat.zero
    var blue = CGFloat.zero
    var alpha = CGFloat.zero
    
    guard getRed(&red, green: &green, blue: &blue, alpha: &alpha) else {
        debugPrint("color could not be retrieved")
        return (1.0, 1.0, 1.0, 1.0)
    }
    return (red, green, blue, alpha)
}

static func == (lhs: UIColor, rhs: UIColor) -> Bool {
    return  lhs.rgba == rhs.rgba
}
}

możesz tego użyć w ten sposób: (cytat z bohery)

UIColor.whiteColor == UIColor(hex: "#FFFFFF") // true
UIColor.black == UIColor(red: 0, green: 0, blue: 0, alpha: 1) // true
div-ane
źródło
-1
if([myimage.backgroundColor isEqual:[UIColor greenColor]])
Nikolai Ruhe
źródło
Ale to jest lepsze niż niektóre inne odpowiedzi tutaj.
powrót prawdziwy