Como comparar UIColors?

127

Gostaria de verificar a cor definida para um plano de fundo em um UIImageView. Eu tentei:

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

mas isso não funciona, mesmo quando eu sei que a cor é verde, ela sempre cai na outra parte.

Além disso, existe uma maneira de produzir a cor atual no console de depuração.

p [myimage backgroundColor]

e

po [myimage backgroundColor]

não trabalha

4thSpace
fonte

Respostas:

176

Você já tentou [myColor isEqual:someOtherColor]?

Steven Canfield
fonte
Obrigado. Qual é a diferença com isEqualTo? Além disso, você sabe como exibi-lo no depurador?
4thSpace 9/06/09
93
A propósito: Tenha cuidado ao comparar cores dessa maneira, pois elas precisam estar no mesmo modelo de cores para serem consideradas iguais. Por exemplo, # ffffffnão é igual [UIColor whiteColor].
zoul
2
Bom ponto Zoul, pode ser mais útil para apontar para uma solução não apenas o problema embora = D
PFrank
11
Bom ponto PFrank, pode ser mais útil para apontar para uma solução não apenas o problema embora = D
Albert Renshaw
Nem sempre funcionou para mim ao comparar um button.tintColor com a cor que eu havia definido. Tinha a ver com arredondamentos. Se você se deparar com isso, veja minha resposta abaixo.
Pbk
75

Como zoul apontou nos comentários, isEqual:retornará NOao comparar cores que estão em diferentes modelos / espaços (por exemplo, #FFFcom [UIColor whiteColor]). Eu escrevi esta extensão UIColor que converte as duas cores no mesmo espaço de cores antes de compará-las:

- (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
fonte
2
Legal, mas acho que há um vazamento. Você nunca libera o CGColorCreate no meio.
borrrden
Esta é uma solução perfeita!
26612
Você pode explicar o que está acontecendo com os quilates? Acho que nunca vi essa sintaxe antes.
Victor Engel
@VictorEngel, UIColor *(^convertColorToRGBSpace)(UIColor*) = ^(UIColor *color) ...está declarando a block. Ele usa mais tarde com convertColorToRGBSpace(self). Para obter uma introdução aos bloqueios no iOS, consulte raywenderlich.com/9328/creating-a-diner-app-using-blocks-part-1
JRG-Developer
1
Eu uso todos os tipos de blocos, mas nunca vi uma sintaxe assim antes. Acho que talvez não tenha usado um bloco que retornou um objeto. É o que está no lado esquerdo do = sobre o qual eu estava postando.
Victor Engel
65

Isso pode ser um pouco tarde demais, mas o CoreGraphics tem uma API mais fácil para conseguir isso:

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

Como a documentação diz:

Indica se duas cores são iguais. Duas cores são iguais se tiverem espaços de cores iguais e componentes de cores numericamente iguais.

Isso resolve muitos problemas e vazamentos / algoritmos personalizados.

DZenBot
fonte
5
[UIColor isEqual:]faz a mesma coisa que isso, não é? A resposta de Mark ainda é a única que verifica a equivalência apesar do espaço de cores.
mattsven
9
Isso não ajuda mais do que UIColor isEqual:se as cores estivessem em diferentes espaços de cores.
Echelon
A questão é sobre a comparação UIColor, não a comparação CGColor.
21717 Sean Sean-Vikoren
Mais preciso do que todas as outras soluções :) +1 de mim
Nirav Gadhiya
8

A solução de samvermette traduzida para rápida:

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
fonte
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
fonte
@Rudolf Adamkovic, é teorema de Pitágoras
Viktor Goltvyanitsa
6

Essa extensão UIColor funciona bem, desde que as cores comparadas possam ser convertidas para o formato RGB, que deve ser a maioria dos casos.

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

Pelo menos com esta extensão:

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

Ambas as comparações retornariam false se comparadas usando o UColor.isEqual nativo (...)

boherna
fonte
5

Eu escrevi esta categoria. Se isEqual:retornar NÃO, ele testará se outras comparações de diferentes componentes ainda podem corresponder. Se possível, modelos diferentes ainda são comparados.

@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
fonte
2

Quando você está comparando myimage.backgroundColor == [UIColor greenColor]assim, se não tiver alterado a backgroundColor para verde antes dessa declaração, ela não estará funcionando.

Eu tive o mesmo problema no meu jogo de cores e resolvi que, usando a equação da diferença simples em cores RGB, você pode dar uma olhada rápida nesse pequeno exemplo de código ColorProcess daqui

é como vencedores responder

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{

}

Em vez desse exemplo de código, você pode usar

include "UIColorProcess.h"

..

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

e, claro, se retornar 0, significa que você está comparando cores muito semelhantes. faixa de retorno é algo como (0.0f - 1.5f) ..

mert
fonte
color.red/blue/green não são suportados por todos os diferentes tipos de classes de cor, verifique os docs
PFrank
1

Alguns erros de arredondamento estranhos podem ocorrer. Esse pode ser o motivo pelo qual um objeto foi definido como uma cor e a cor que você definiu para não corresponder exatamente.

Foi assim que eu resolvi:

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

}

Esse código pode ser aprimorado não apenas comparando 1, mas também comparando todos os componentes. Por exemplo, vermelho + verde + azul + alfa == vermelho2 + verde2 + azul2 + alfa2

Pbk
fonte
1
As cores não são a mesma coisa se comparados pelo único componente verde
Ben Sinclair
Essa é a única resposta que menciona e tenta solucionar possíveis erros de arredondamento que podem surgir ao comparar cores definidas por diferentes meios; portanto, embora ele se concentre apenas no verde, o exemplo (como o autor da resposta menciona) pode ser generalizado. Como tal, e como o arredondamento era, de fato, o problema que eu estava enfrentando, achei esta resposta útil.
Matt Wagner
1

Estou usando esta extensão que está funcionando para mim em todos os casos.

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

A esperança ajuda alguém.

Nota: #ffffffé igual a [UIColor whiteColor]esta extensão

arunit21
fonte
Isso funciona ao comparar cores em espaços de cores?
Vaddadi Kartick 31/03
Não tenho certeza, não testei para todos os espaços de cores.
Arunit21
1

As outras soluções não funcionaram corretamente. Aqui está uma abordagem que funciona no 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 }
    }

}
Steve U
fonte
0

A respeito:

+(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
fonte
isso pode não funcionar para casos de borda como uma cor de padrão. do doc Se a cor estiver em um espaço de cor compatível, ela será convertida para o formato RGB e seus componentes serão retornados ao seu aplicativo. Se a cor não estiver em um espaço de cores compatível, os parâmetros permanecerão inalterados. Portanto, você pode instanciar cada float -1e, se algum ainda tiver esse valor após a chamada getRed:green:blue:alpha:, você sabe que a comparação falhou. (ou não omitir o boolean retornado como ele vai dizer se ele foi chamado com êxito.)
vikingosegundo
1
Acabei de verificar: embora seja possível verificar o monocromático em relação às cores RGBA na teoria, ele não funcionará com o seu código, pois getRed:free:blue:alpha:não será bem-sucedido em uma cor monocromática. Portanto, seu código não produzirá outro resultado além de is equal:. por favor, veja minha resposta sobre como lidar com isso.
31414
+1 por rigor! O código acima funciona para o meu caso simples, mas parece que não é uma bala de prata. Coisa boa.
Dooleyo 31/03
0

Aqui está uma extensão para mudar para o RGC Space Color no 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
fonte
0

Extensão para o UIColor, usando os recursos do Swift 2.2. Observe no entanto que, como os valores RGBA são comparados e são CGFloat, os erros de arredondamento podem fazer com que as cores não sejam retornadas iguais se não forem exatamente iguais (por exemplo, elas não foram criadas originalmente usando exatamente as mesmas propriedades no 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
fonte
0

Extensão 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
fonte
0

Eu converti a resposta do raf para o Swift 4 (muitas alterações na CGColorAPI), removi o desembrulhamento forçado e diminuiu o recuo graças ao uso generoso 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
fonte
0

Por que não adicionar a extensão com protocolo equável? Esta resposta está usando a solução de Nicolas Miari. Então, se você gosta desta resposta, seja bem-vindo a gostar da resposta dele (a segunda do topo)

O comentário de Zoul: Tenha cuidado ao comparar cores dessa maneira, pois elas precisam estar no mesmo modelo de cores para serem consideradas iguais. Por exemplo, #ffffff não é igual a [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
fonte
0

Enquanto resposta de @ samvermette é muito bom, eu descobri que às vezes pode levar a falsos negativos quando se comparam os tipos de cores diferentes (no meu caso UIDeviceRGBColora UICachedDeviceWhiteColor). Corrigi-o criando explicitamente a cor no `else 'também:

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

Você tem que usar

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

Documentação aqui .

Matteo Gobbi
fonte
-1
if([myimage.backgroundColor isEqual:[UIColor greenColor]])
Nikolai Ruhe
fonte
Mas é melhor do que algumas outras respostas aqui.
return true