Comment comparer UIColors?

127

Je voudrais vérifier le jeu de couleurs pour un arrière-plan sur une UIImageView. J'ai essayé:

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

mais cela ne fonctionne pas, même quand je sais que la couleur est verte, elle tombe toujours dans l'autre partie.

Existe-t-il également un moyen de générer la couleur actuelle dans la console de débogage.

p [myimage backgroundColor]

et

po [myimage backgroundColor]

ne marche pas.

4thSpace
la source

Réponses:

176

Avez-vous essayé [myColor isEqual:someOtherColor]?

Steven Canfield
la source
Merci. Quelle est la différence avec isEqualTo? De plus, savez-vous comment l'afficher dans le débogueur?
4thSpace
93
À propos: soyez prudent lorsque vous comparez les couleurs de cette façon, car elles doivent être dans le même modèle de couleur pour être considérées comme égales. Par exemple, # ffffffn'est pas égal [UIColor whiteColor].
zoul
2
Bon point Zoul, il serait peut-être plus utile de pointer vers une solution et pas seulement le problème = D
pfrank
11
Bon point Pfrank, il serait peut-être plus utile d'indiquer une solution pas seulement le problème = D
Albert Renshaw
Cela ne fonctionnait pas toujours pour moi lorsque je comparais un button.tintColor à la couleur que je l'avais définie. Eu à voir avec l'arrondissement. Si vous rencontrez cela, voyez ma réponse ci-dessous.
Pbk du
75

Comme zoul l'a souligné dans les commentaires, isEqual:reviendra NOlors de la comparaison de couleurs qui se trouvent dans différents modèles / espaces (par exemple #FFFavec [UIColor whiteColor]). J'ai écrit cette extension UIColor qui convertit les deux couleurs dans le même espace colorimétrique avant de les comparer:

- (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
la source
2
Bien, mais il y a une fuite je pense. Vous ne relâchez jamais CGColorCreate au milieu.
borrrden
C'est une solution parfaite!
seul
Pouvez-vous expliquer ce qui se passe avec les carats? Je ne pense pas avoir vu cette syntaxe auparavant.
Victor Engel
@VictorEngel, UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color) ...déclare un block. Il l'utilise plus tard avec convertColorToRGBSpace(self). Pour une introduction aux blocs dans iOS, voir raywenderlich.com/9328/creating-a-diner-app-using-blocks-part-1
JRG-Developer
1
J'utilise des blocs tout le temps, mais je n'ai jamais vu une syntaxe comme celle-ci auparavant. Je suppose que je n'ai peut-être pas utilisé un bloc qui a renvoyé un objet. C'est ce qui se trouve sur le côté gauche du = sur lequel je postais.
Victor Engel
65

Cela pourrait être un peu trop tard, mais CoreGraphics a une API plus simple pour y parvenir:

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

Comme le dit la documentation:

Indique si deux couleurs sont égales. Deux couleurs sont égales si elles ont des espaces colorimétriques égaux et des composants de couleur numériquement égaux.

Cela résout beaucoup de problèmes et d'algorithmes fuyants / personnalisés.

DZenBot
la source
5
[UIColor isEqual:]fait la même chose, n'est-ce pas? La réponse de Mark est toujours la seule qui vérifie bien l'équivalence malgré l'espace colorimétrique.
mattsven
9
Cela n'aide pas plus que UIColor isEqual:si les couleurs sont dans des espaces colorimétriques différents.
Echelon
La question concerne la comparaison UIColor, pas la comparaison CGColor.
Sean Vikoren
Plus précis que toutes les autres solutions :) +1 de ma part
Nirav Gadhiya
8

La solution de samvermette traduite en rapide:

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
la source
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
la source
@Rudolf Adamkovic, c'est le théorème de Pythagore
Viktor Goltvyanitsa
6

Cette extension UIColor fonctionne bien à condition que les couleurs comparées puissent être converties au format RVB, ce qui devrait être la plupart des cas.

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

Au moins avec cette extension:

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

Les deux comparaisons renverraient false si elles étaient comparées à l'aide de l'UColor.isEqual natif (...)

Boherna
la source
5

J'ai écrit cette catégorie. Si isEqual:renvoie NON, il testera si une comparaison supplémentaire des différents composants peut toujours correspondre. Si possible, différents modèles sont encore comparés.

@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
la source
2

Lorsque vous comparez myimage.backgroundColor == [UIColor greenColor]comme ça, si vous n'avez pas changé le backgroundColor en vert avant cette déclaration, cela ne fonctionne pas.

J'ai eu le même problème dans mon jeu de couleurs et j'ai résolu qu'en utilisant une simple équation de différence dans les couleurs RVB, vous pouvez rapidement jeter un coup d'œil à cet échantillon de code court ColorProcess à partir d' ici

c'est comme la réponse des vainqueurs

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{

}

Au lieu de cet exemple de code, vous pouvez utiliser

include "UIColorProcess.h"

..

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

et bien sûr, s'il renvoie 0, cela signifie que vous comparez une couleur trop similaire. la plage de retour est quelque chose comme (0.0f - 1.5f).

mert
la source
color.red/blue/green ne sont pas pris en charge pour tous les types de classes de couleurs, consultez la documentation
pfrank
1

Des erreurs d'arrondi étranges peuvent se produire. Cela peut être la raison pour laquelle un objet défini sur une couleur et la couleur pour laquelle vous le définissez ne correspondent pas exactement.

Voici comment je l'ai résolu:

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

}

Ce code peut être amélioré non seulement en comparant 1 mais en comparant tous les composants. Par exemple, rouge + vert + bleu + alpha == rouge2 + vert2 + bleu2 + alpha2

Pbk
la source
1
Les couleurs ne sont pas les mêmes si on les compare uniquement par la composante verte
Ben Sinclair
C'est la seule réponse qui mentionne et tente de résoudre les erreurs d'arrondi potentielles qui peuvent survenir lors de la comparaison des couleurs définies par différents moyens; ainsi, alors qu'il se concentre uniquement sur le vert, l'exemple (comme le mentionne l'auteur de la réponse) peut être généralisé. En tant que tel, et comme l'arrondi était en fait le problème que je rencontrais, j'ai trouvé cette réponse utile.
Matt Wagner
1

J'utilise cette extension qui fonctionne pour moi dans tous les cas.

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

L'espoir aide quelqu'un.

Remarque: #ffffffest égal à [UIColor whiteColor]par cette extension

arunit21
la source
Cela fonctionne-t-il en comparant les couleurs entre les espaces colorimétriques?
Vaddadi Kartick
Pas sûr, je ne l'ai pas testé pour tous les espaces colorimétriques.
arunit21
0

Qu'en est-il de:

+(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
la source
cela peut ne pas fonctionner pour les cas de bord comme couleur de motif. from doc Si la couleur se trouve dans un espace colorimétrique compatible, la couleur est convertie au format RVB et ses composants sont renvoyés à votre application. Si la couleur n'est pas dans un espace colorimétrique compatible, les paramètres restent inchangés. Ainsi, vous pouvez instancier chaque float avec -1et si l'un d'eux a toujours cette valeur après l'appel getRed:green:blue:alpha:, vous savez que la comparaison a échoué. (ou n'omettez pas le booléen renvoyé car il vous dira s'il a été appelé avec succès.)
vikingosegundo
1
Je viens de vérifier: bien qu'il soit possible de vérifier le monochrome par rapport aux couleurs RGBA en théorie, cela ne fonctionnera pas avec votre code, car getRed:free:blue:alpha:ne réussira pas sur une couleur monochrome. Donc, votre code ne donnera pas un autre résultat que is equal:. s'il vous plaît voir ma réponse comment y faire face.
vikingosegundo
+1 pour la rigueur! Le code ci-dessus fonctionne pour mon cas simple, mais il semblerait que ce ne soit pas une solution miracle. Bon produit.
dooleyo
0

Voici une extension pour passer à la RGC Space Color dans 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
la source
0

Extension à UIColor, utilisant les fonctionnalités Swift 2.2. Notez cependant que comme les valeurs RGBA sont comparées, et qu'il s'agit de CGFloat, des erreurs d'arrondi peuvent faire que les couleurs ne soient pas renvoyées comme égales si elles ne sont pas exactement les mêmes (par exemple, elles n'ont pas été créées à l'origine en utilisant exactement les mêmes propriétés dans l'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
la source
0

Extension 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
la source
0

J'ai converti la réponse de raf en Swift 4 (beaucoup de changements dans l' CGColorAPI), supprimé le déballage de la force et diminué l'indentation grâce à une utilisation généreuse de 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
la source
0

Pourquoi ne pas ajouter l'extension avec un protocole équivalent? Cette réponse utilise la solution de Nicolas Miari. Donc, si vous aimez cette réponse, soyez le bienvenu pour aimer sa réponse (deuxième à partir du haut)

Le commentaire de Zoul: Soyez prudent lorsque vous comparez les couleurs de cette façon, car elles doivent être dans le même modèle de couleur pour être considérées comme égales. Par exemple, #ffffff n'est pas égal à [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
la source
0

Alors que la réponse de @ samvermette est très bon, je l' ai trouvé qu'il peut parfois conduire à des faux négatifs lorsque l'on compare les différents types de couleurs (dans mon cas UIDeviceRGBColorà UICachedDeviceWhiteColor). Je l'ai corrigé en créant explicitement la couleur dans le «else» aussi:

- (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];
}
HACHE
la source
0

Vous devez utiliser

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

Documentation ici .

Matteo Gobbi
la source
-1
if([myimage.backgroundColor isEqual:[UIColor greenColor]])
Nikolai Ruhe
la source
Mais c'est mieux que d'autres réponses ici.
retour vrai