Comment comparer UIColors?

Je voudrais vérifier le jeu de couleurs pour l'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 le vert, il tombe toujours dans la partie.

Aussi, est-il un moyen de sortie de la couleur dans la console de débogage.

p [myimage backgroundColor]

po [myimage backgroundColor]

ne fonctionnent pas.

InformationsquelleAutor 4thSpace | 2009-06-09

175

Avez-vous essayé [myColor isEqual:someOtherColor] ?
- Merci. Quelle est la différence avec isEqualTo? Aussi, savez-vous comment faire pour l'afficher dans le débogueur?
- Par la route: Être prudent lorsque l'on compare les couleurs de cette façon, parce qu'ils doivent être dans le même modèle de couleur pour être considérées comme égales. Par exemple, #ffffff n'est pas égale à [UIColor whiteColor].
- Bon point de Zoul, peut-être plus utile pour pointer vers une solution non seulement le problème =D
- Bon point Pfrank, peut-être plus utile pour pointer vers une solution non seulement le problème =D
- N'ont pas toujours le cas pour moi lors de la comparaison d'un bouton.nuance de couleur pour la couleur j'ai eu des ensemble pour. Avait à faire avec l'arrondissement. Si vous pouvez le voir ma réponse ci-dessous.
- Comme une solution, je n'ai pas encore testé, mais peut-être obtenir le CGColor de la UIColor fixe la comparaison de problème, étant donné que devrait obtenir juste à droite vers le bas dans les valeurs des couleurs et pas leurs types.
InformationsquelleAutor Steven Canfield
74

Comme zoul souligné dans les commentaires, isEqual: sera de retour NO lorsque l'on compare les couleurs qui sont en différents modèles/espace (par exemple #FFF avec [UIColor whiteColor]). J'ai écrit ce UIColor extension qui convertit les deux couleurs pour le même espace de couleur 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];
}
```
- Sympa, mais il y a une fuite, je pense. Vous n'avez jamais relâcher la CGColorCreate dans le milieu.
- C'est une solution parfaite!
- Assez bien travaillé
- Pouvez-vous expliquer ce qu'il se passe avec l'carats? Je ne pense pas que je ai vu que la syntaxe avant.
- est la déclaration d'une block. Il l'utilise, plus tard, avec convertColorToRGBSpace(self). Pour une intro de blocs dans iOS, voir raywenderlich.com/9328/creating-a-diner-app-using-blocks-part-1
- J'utilise des blocs de toutes les dents, mais je n'ai jamais vu une syntaxe tout à fait comme cela avant. Je suppose que peut-être que je n'ai pas utilisé un bloc qui a retourné un objet. C'est ce qui est sur le côté gauche de l' = que j'ai été poster sur.
- Excellente solution, mais personnellement je n'aime pas l'utilisation de blocs de cette façon, alors je l'ai modifié juste pour être une fonction. Il doit accepter la palette comme un argument bien sûr, mais il fonctionne très bien et je suis sûr que c'est plus efficace si vous faites cela souvent.
InformationsquelleAutor samvermette
65

Cela peut être un peu trop tard, mais CoreGraphics, il est plus facile de l'API pour atteindre cet:
```
CGColorEqualToColor(myColor.CGColor, [UIColor clearColor].CGColor)
```
Comme le dit la documentation:

Indique si les deux couleurs sont égaux.
Deux couleurs sont égaux s'ils ont les mêmes espaces de couleurs et numériquement égal composantes de couleur.

Cela résout beaucoup de problèmes et la fuite/algorithmes personnalisés.
- Ce doit être la accepté de répondre.
- [UIColor isEqual:] fait la même chose que ce, n'est-ce pas? Marc réponse est encore le seul qui vérifie l'équivalence en dépit de la couleur de l'espace de bien.
- Cela ne vous aide pas, pas plus que UIColor isEqual: si les couleurs sont dans les différents espaces de couleurs.
- La question est concernant UIColor comparaison, pas CGColor comparaison.
- Plus précise que toutes les autres solutions 🙂 +1 de moi
- Celui-ci fonctionne sur isEqual: .
InformationsquelleAutor DZenBot

samvermette la solution traduit à swift:

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

InformationsquelleAutor raf

#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{
...
}

que les pensions de titres sont maintenant au github.com/thetaplab/uicolor-utilities
C'est illisible.
Adamkovic, c'est le théorème de Pythagore

InformationsquelleAutor Viktor Goltvyanitsa

Ce UIColor extension fonctionne très bien à condition que les couleurs peuvent être convertis en format RGB, 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 return false si on la compare à l'aide de la maternelle UColor.isEqual(...)

InformationsquelleAutor boherna

J'ai écrit cette catégorie. Si isEqual: ne reviendrons PAS, il permettra de tester si une comparaison plus poussée des différents composants peut toujours correspondre. Si possible, les différents modèles sont toujours 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

InformationsquelleAutor vikingosegundo

2

Lorsque vous comparez les myimage.backgroundColor == [UIColor greenColor] comme cela si vous navez pas changer le backgroundColor vert à l'avant de cette affirmation, il n'est pas de travail.

J'ai eu le même problème dans mon jeu de couleur et j'ai résolu en utilisant une simple équation aux différences de couleurs RGB, vous pouvez rapidement prendre un coup d'oeil qui court exemple de code ColorProcess de ici

son comme vainqueurs réponse
```
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, si elle renvoie la valeur 0, cela signifie que vous êtes en comparant trop de couleurs similaires. de retour de gamme est quelque chose comme (0.0 f - 1.5 f)..
- couleur.rouge/bleu/vert ne sont pas pris en charge pour tous les différents types de classes de couleurs, consultez la documentation
InformationsquelleAutor mert
1

Un peu bizarre, des erreurs d'arrondi peuvent se produire. Cela peut être la raison d'un objet d'une couleur et la couleur que vous définissez à ne pas correspondre exactement.

C'est 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 de comparer tous les composants. Par exemple rouge+vert+bleu+alpha == red2+green2+blue2+alpha2
- Les couleurs ne sont pas les mêmes si on les compare par composante verte seulement
- C'est la seule réponse que les mentions et les tentatives pour remédier à d'éventuels erreurs d'arrondi qui peuvent surgir lors de la comparaison de couleurs qui sont définies par différents moyens; ainsi, même s'il ne met l'accent que sur le vert, l'exemple (comme l'auteur de la réponse mentionne) peut être généralisée. En tant que tel, et depuis que l'arrondissement a été, en fait, le problème que j'ai est, j'ai trouvé cette réponse utile.
InformationsquelleAutor Pbk

Je suis l'aide de cette extension qui travaille 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 ****/

Espoir aide à quelqu'un.

Remarque: #ffffff ne l'égalité des [UIColor whiteColor] par cette extension

Est-ce de travailler tout en comparant les couleurs à travers les espaces de couleur?
Pas sûr, je n'ai pas testé pour tous les espaces de couleurs.

InformationsquelleAutor arunit21

0

Ce sujet:
```
+(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);
}
```
- cela pourrait ne pas fonctionner pour les cas limites comme un motif de couleur. de doc Si la couleur est compatible espace de couleur, la couleur est convertie dans le format RGB et ses composants sont retournées à votre demande. Si la couleur n'est pas compatible d'un espace de couleur, les paramètres sont inchangés. de Sorte que vous peut instancier chaque flotteur avec -1 et si a toujours cette valeur après l'appel de getRed:green:blue:alpha:, vous savez la comparaison a échoué. (ou ne pas omettre le retourné boolean qu'il vous dira si il a été appelé avec succès.)
- Je viens de vérifier: bien qu'il soit possible de vérifier monochrome contre RGBA couleurs en théorie, il ne fonctionnera pas avec votre code, comme getRed:free:blue:alpha: l'habitude de réussir sur un monochrome de couleur. Si votre code ne produisent pas un résultat autre que celui is equal:. veuillez voir ma réponse à la façon de traiter avec elle.
- +1 pour la perfection! Le code ci-dessus fonctionne pour mon cas simple, mais il semblerait que c'est pas la panacée. De bonnes choses.
InformationsquelleAutor dooleyo

Ici est une extension de passer à la RGC de l'Espace de Couleur 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
}

}

InformationsquelleAutor RyanPliske

Extension de UIColor, l'utilisation de Swift 2.2 caractéristiques.
Notez toutefois qu'en raison de la R, G, B, les valeurs sont comparées, et ce sont CGFloat, les erreurs d'arrondi peuvent faire que les couleurs sont non retourné comme égales si elles ne sont pas exactement les mêmes (par exemple, ils n'ont pas été initialement créé 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
}

InformationsquelleAutor HixField

UIColor extension

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

InformationsquelleAutor uranpro

J'ai converti raf répondre à Swift 4 (beaucoup de changements dans le CGColor API), enlevé de force à déballer et une diminution de l'indentation grâce à l'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)
}
}

InformationsquelleAutor Nicolas Miari

Pourquoi ne pas ajouter l'extension avec equatable protocole?
Cette réponse est à l'aide de la solution de Nicolas Miari. Donc, si vous aimez cette réponse, s'il vous plaît être la bienvenue comme sa réponse (deuxième à partir du haut)

Le commentaire de Zoul: Être prudent lorsque l'on compare les couleurs de cette façon, parce qu'ils doivent être dans le même modèle de couleur pour être considérées comme égales. Par exemple, #ffffff n'est pas égale à [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)
}

InformationsquelleAutor Illya Krit

Tandis que @samvermette la réponse est très bon, j'ai trouvé que cela peut conduire à des faux négatifs lorsque l'on compare les différents types de couleur (dans mon cas UIDeviceRGBColor à UICachedDeviceWhiteColor). Je l'ai corrigé en créant explicitement la couleur dans le `else', trop:

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

InformationsquelleAutor AXE

Les autres solutions ne fonctionnent pas correctement. Voici une approche qui fonctionne dans Swift:

import CoreGraphics
extension UIColor {
/**
Checks for visual equality of two colors regardless of their color space.
- parameter    color:  The other color for comparison.
- returns:     A boolean representing whether the colors are visually the same color.
*/
public func isVisuallyEqualTo(_ color: UIColor) -> Bool {
return rgbaComponents == color.rgbaComponents
}
public var rgbaComponents: [CGFloat] {
var data = [CUnsignedChar](repeating: 0, count: 4)
let colorSpace = CGColorSpaceCreateDeviceRGB()
let context = CGContext(data: &data,
width: 1, height: 1,
bitsPerComponent: 8, bytesPerRow: 4,
space: colorSpace,
bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)
context?.setFillColor(cgColor)
context?.fill(CGRect(x: 0, y: 0, width: 1, height: 1))
return data.map { CGFloat($0) / 255.0 }
}
}

InformationsquelleAutor Steve Uffelman

-1
```
if([myimage.backgroundColor isEqual:[UIColor greenColor]])
```
- Mais c'est mieux que certains autres réponses ici.
InformationsquelleAutor Nikolai Ruhe

Vous devez vous connecter pour publier un commentaire.