Cómo comparar UIColors?

Me gustaría comprobar el conjunto de colores para un fondo en un UIImageView. He intentado:

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

pero eso no funciona, incluso cuando sé que el color es verde, siempre cae en la parte else.

Además, ¿hay alguna manera de mostrar el color actual en la consola de depuración?

 p [myimage backgroundColor] 

y

 po [myimage backgroundColor] 

no funciona

¿Has probado [myColor isEqual:someOtherColor] ?

Como zoul señaló en los comentarios, isEqual: devolverá NO al comparar colores que están en diferentes modelos / espacios (por ejemplo #FFF con [UIColor whiteColor] ). Escribí esta extensión de UIColor que convierte ambos colores en el mismo espacio de color antes de compararlos:

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

Esto podría ser un poco tarde, pero CoreGraphics tiene una API más fácil para lograr esto:

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

Al igual que la documentación dice:

Indica si dos colores son iguales. Dos colores son iguales si tienen espacios de color iguales y componentes de color numéricamente iguales.

Esto resuelve muchos problemas y algoritmos de fuga / personalizado.

La solución de samvermette traducida a veloz:

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

Escribí esta categoría Si isEqual: devuelve NO, se probará si la comparación adicional de los diferentes componentes aún puede coincidir. Si es posible, se siguen comparando diferentes modelos.

 @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 

Esta extensión UIColor funciona bien siempre que los colores comparados se puedan convertir a formato RGB, lo que debería ser la mayoría de los 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 } } 

Al menos con esta extensión:

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

Ambas comparaciones resultarían falsas si se comparan con el UColor.isEqual nativo (…)

Cuando myimage.backgroundColor == [UIColor greenColor] esta manera si no has cambiado backgroundColor a green antes de esa statement, no está funcionando.

Tuve el mismo problema en mi juego de color y resolví que al usar ecuación de diferencia simple en colores RGB, puedes echar un vistazo rápido al ejemplo de código corto ColorProcess desde aquí

es como respuesta vencedores

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

En lugar de esa muestra de código, puede usar

 include "UIColorProcess.h" .. float distance = [UIColorProcess findDistanceBetweenTwoColor:[UIColor redColor] secondColor:[UIColor blueColor]]; 

y, por supuesto, si devuelve 0, significa que está comparando un color demasiado similar. el rango de retorno es algo así como (0.0f - 1.5f) ..

Estoy usando esta extensión que funciona para mí en todos los 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 ****/ 

La esperanza ayuda a alguien.

Nota: #ffffff es igual a [UIColor whiteColor] por esta extensión

Qué pasa:

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

Pueden producirse algunos errores de redondeo extraños. Esa puede ser la razón por la que un objeto configurado en un color y el color que lo configura no coinciden exactamente.

Así es como lo resolví:

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

Este código se puede mejorar no solo comparando 1 sino comparando todos los componentes. Por ejemplo, rojo + verde + azul + alfa == rojo2 + verde2 + azul2 + alfa2

Aquí hay una extensión para cambiar al color espacial RGC en 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 } 

}

Extensión a UIColor, usando las características de Swift 2.2. Sin embargo, tenga en cuenta que debido a que los valores RGBA se comparan, y estos son CGFloat, los errores de redondeo pueden hacer que los colores no se devuelvan igual si no son exactamente iguales (p. Ej., No se crearon originalmente usando exactamente las mismas propiedades en el 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 } 

Extensión 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; } 

He convertido la respuesta de raf a Swift 4 (muchos cambios en la API de CGColor ), CGColor el CGColor fuerza y ​​disminuí la sangría gracias al 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) } } 
 if([myimage.backgroundColor isEqual:[UIColor greenColor]])