Eu estava procurando ser capaz de transformar qualquer UIColor em um gradiente. A maneira como pretendo fazer isso é usar o Core Graphics para desenhar um gradiente. O que estou tentando fazer é obter uma cor, digamos:

[UIColor colorWithRed:0.5 green:0.5 blue:0.5 alpha:1.0];

e obtenha um UIColor que é alguns tons mais escuro e alguns tons mais claro. Alguém sabe como fazer isso? Obrigado.

- (UIColor *)lighterColorForColor:(UIColor *)c
{
    CGFloat r, g, b, a;
    if ([c getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MIN(r + 0.2, 1.0)
                               green:MIN(g + 0.2, 1.0)
                                blue:MIN(b + 0.2, 1.0)
                               alpha:a];
    return nil;
}

- (UIColor *)darkerColorForColor:(UIColor *)c
{
    CGFloat r, g, b, a;
    if ([c getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MAX(r - 0.2, 0.0)
                               green:MAX(g - 0.2, 0.0)
                                blue:MAX(b - 0.2, 0.0)
                               alpha:a];
    return nil;
}

Use-o assim:

UIColor *baseColor = // however you obtain your color
UIColor *lighterColor = [self lighterColorForColor:baseColor];
UIColor *darkerColor = [self darkerColorForColor:baseColor];

EDIT : como apontou @Anchu Chimala, para flexibilidade máxima, esses métodos devem ser implementados como uma categoria UIColor. Além disso, a partir da ideia de @ Riley, pode ser uma idéia melhor tornar a cor propriamente mais escura ou mais clara, em vez de adicionar ou subtrair valores constantes. Como o @jrturton apontou, não é necessário manipular os componentes RGB; é melhor modificar a propriedade de brilho em si. Contudo:

@implementation UIColor (LightAndDark)

- (UIColor *)lighterColor
{
    CGFloat h, s, b, a;
    if ([self getHue:&h saturation:&s brightness:&b alpha:&a])
        return [UIColor colorWithHue:h
                          saturation:s
                          brightness:MIN(b * 1.3, 1.0)
                               alpha:a];
    return nil;
}

- (UIColor *)darkerColor
{
    CGFloat h, s, b, a;
    if ([self getHue:&h saturation:&s brightness:&b alpha:&a])
        return [UIColor colorWithHue:h
                          saturation:s
                          brightness:b * 0.75
                               alpha:a];
    return nil;
}
@end

TL; DR:

Rápido:

extension UIColor {

    var lighterColor: UIColor {
        return lighterColor(removeSaturation: 0.5, resultAlpha: -1)
    }

    func lighterColor(removeSaturation val: CGFloat, resultAlpha alpha: CGFloat) -> UIColor {
        var h: CGFloat = 0, s: CGFloat = 0
        var b: CGFloat = 0, a: CGFloat = 0

        guard getHue(&h, saturation: &s, brightness: &b, alpha: &a)
            else {return self}

        return UIColor(hue: h,
                       saturation: max(s - val, 0.0),
                       brightness: b,
                       alpha: alpha == -1 ? a : alpha)
    }
}

Uso:

let lightColor = somethingDark.lighterColor

Objetivo-C:

- (UIColor *)lighterColorRemoveSaturation:(CGFloat)removeS
                              resultAlpha:(CGFloat)alpha {
    CGFloat h,s,b,a;
    if ([self getHue:&h saturation:&s brightness:&b alpha:&a]) {
        return [UIColor colorWithHue:h
                          saturation:MAX(s - removeS, 0.0)
                          brightness:b
                               alpha:alpha == -1? a:alpha];
    }
    return nil;
}

- (UIColor *)lighterColor {
    return [self lighterColorRemoveSaturation:0.5
                                  resultAlpha:-1];
}

@rchampourlier estava certo em seu comentário para @ user529758 (A resposta aceita) - As soluções HSB (ou HSV) e RGB oferecem resultados completamente diferentes. O RGB apenas adiciona (ou aproxima a cor) o branco, e a solução HSB aproxima a cor da borda na escala Brigtness - que basicamente começa com preto e termina com a cor pura ...

Basicamente, o brilho (valor) torna a cor menos ou mais próxima do preto, enquanto a saturação a torna menos ou mais próxima do branco ...

Como visto aqui:

Portanto, a solução para fazer uma cor realmente brilhante (ou seja, mais perto de branco ...) será para torná-lo do valor de saturação menor , resultando esta solução:

- (UIColor *)lighterColor {
    CGFloat h,s,b,a;
    if ([self getHue:&h saturation:&s brightness:&b alpha:&a]) {
        return [UIColor colorWithHue:h
                          saturation:MAX(s - 0.3, 0.0)
                          brightness:b /*MIN(b * 1.3, 1.0)*/
                               alpha:a];
    }
    return nil;
}

Extensão universal Swift para iOS e OS X , usando getHue :

#if os(OSX)

    import Cocoa
    public  typealias PXColor = NSColor

    #else

    import UIKit
    public  typealias PXColor = UIColor

#endif

    extension PXColor {

    func lighter(amount : CGFloat = 0.25) -> PXColor {
        return hueColorWithBrightnessAmount(1 + amount)
    }

    func darker(amount : CGFloat = 0.25) -> PXColor {
        return hueColorWithBrightnessAmount(1 - amount)
    }

    private func hueColorWithBrightnessAmount(amount: CGFloat) -> PXColor {
        var hue         : CGFloat = 0
        var saturation  : CGFloat = 0
        var brightness  : CGFloat = 0
        var alpha       : CGFloat = 0

        #if os(iOS)

            if getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha) {
                return PXColor( hue: hue,
                                saturation: saturation,
                                brightness: brightness * amount,
                                alpha: alpha )
            } else {
                return self
            }

            #else

            getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
            return PXColor( hue: hue,
                            saturation: saturation,
                            brightness: brightness * amount,
                            alpha: alpha )

        #endif

    }

}

Uso:

let color = UIColor(red: 0.5, green: 0.8, blue: 0.8, alpha: 1.0)
color.lighter(amount:0.5)
color.darker(amount:0.5)

OU (com os valores padrão):

color.lighter()
color.darker()

Amostra:

Eu só queria dar o mesmo resultado, em RGB, do que

• colocando a cor com alfa x% sobre um fundo branco para clarear
• colocando a cor com alfa x% sobre um fundo preto para escurecer

O que dá o mesmo resultado, AFAIK, do que escolher a cor em um gradiente 'cor para branco' ou 'cor para preto', em x% do tamanho do gradiente.

Para esse propósito, a matemática é simples:

extension UIColor {
    func mix(with color: UIColor, amount: CGFloat) -> UIColor {
        var red1: CGFloat = 0
        var green1: CGFloat = 0
        var blue1: CGFloat = 0
        var alpha1: CGFloat = 0

        var red2: CGFloat = 0
        var green2: CGFloat = 0
        var blue2: CGFloat = 0
        var alpha2: CGFloat = 0

        getRed(&red1, green: &green1, blue: &blue1, alpha: &alpha1)
        color.getRed(&red2, green: &green2, blue: &blue2, alpha: &alpha2)

        return UIColor(
            red: red1 * (1.0 - amount) + red2 * amount,
            green: green1 * (1.0 - amount) + green2 * amount,
            blue: blue1 * (1.0 - amount) + blue2 * amount,
            alpha: alpha1
        )
    }
}

Aqui estão alguns exemplos com algumas cores

A solução de user529758 no Swift:

Cor mais escura:

func darkerColorForColor(color: UIColor) -> UIColor {

       var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0

       if color.getRed(&r, green: &g, blue: &b, alpha: &a){
           return UIColor(red: max(r - 0.2, 0.0), green: max(g - 0.2, 0.0), blue: max(b - 0.2, 0.0), alpha: a)
       }

       return UIColor()
}

Cor mais clara:

func lighterColorForColor(color: UIColor) -> UIColor {

       var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0

       if color.getRed(&r, green: &g, blue: &b, alpha: &a){
           return UIColor(red: min(r + 0.2, 1.0), green: min(g + 0.2, 1.0), blue: min(b + 0.2, 1.0), alpha: a)
       }

       return UIColor()
}

Se você converter a cor RGB no modelo de cores HSL , poderá alterar o componente L = luminosidade de L = 0,0 (preto) sobre L = 0,5 (cor natural) para L = 1,0 (branco). UIColornão pode manipular HSL diretamente, mas há uma fórmula para converter RGB <-> HSL.

Nenhuma das soluções postadas funcionou bem para todas as cores e tons, mas então eu me deparei com essa biblioteca, que fornece um conjunto de extensões muito bem implementadas para o UIColor.

Especificamente, ele tem uma função lighten como parte de sua implementação HSL: (UIColor *)lighten:(CGFloat)amount- que funciona perfeitamente.

Sebyddd solução como uma extensão:

extension UIColor {    
    func darker() -> UIColor {

        var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0

        if self.getRed(&r, green: &g, blue: &b, alpha: &a){
            return UIColor(red: max(r - 0.2, 0.0), green: max(g - 0.2, 0.0), blue: max(b - 0.2, 0.0), alpha: a)
        }

        return UIColor()
    }

    func lighter() -> UIColor {

        var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0

        if self.getRed(&r, green: &g, blue: &b, alpha: &a){
            return UIColor(red: min(r + 0.2, 1.0), green: min(g + 0.2, 1.0), blue: min(b + 0.2, 1.0), alpha: a)
        }

        return UIColor()
    }
}

Uso:

let darkerYellow = UIColor.yellow.darker()
let lighterYellow = UIColor.yellow.lighter()

Se você deseja que a solução do user529758 funcione com tons de cinza (como [UIColor lightGrayColor]ou [UIColor darkGrayColor] você precisa aprimorá- la assim:

- (UIColor *)lighterColor
{
    CGFloat h, s, b, a;
    if ([self getHue:&h saturation:&s brightness:&b alpha:&a]) {
        return [UIColor colorWithHue:h
                          saturation:s
                          brightness:MIN(b * 1.3, 1.0)
                               alpha:a];
    }

    CGFloat white, alpha;
    if ([self getWhite:&white alpha:&alpha]) {
        white = MIN(1.3*white, 1.0);
        return [UIColor colorWithWhite:white alpha:alpha];
    }

    return nil;
}

getHue:saturation:brightness:alphafalha (e retorna false) quando chamado em um tom cinza, portanto, você precisará usá-lo getWhite:alpha.

UIColor extensão e fixação mais leveColorForColor

extension UIColor {
  class func darkerColorForColor(color: UIColor) -> UIColor {
    var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0
    if color.getRed(&r, green: &g, blue: &b, alpha: &a){
      return UIColor(red: max(r - 0.2, 0.0), green: max(g - 0.2, 0.0), blue: max(b - 0.2, 0.0), alpha: a)
    }
    return UIColor()
  }

  class func lighterColorForColor(color: UIColor) -> UIColor {
    var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0
    if color.getRed(&r, green: &g, blue: &b, alpha: &a){
      let tmpColor = UIColor(red: min(r + 0.2, 1.0), green: min(g + 0.2, 1.0), blue: min(b + 0.2, 1.0), alpha: a)
      println(tmpColor)
      return tmpColor
    }
    return UIColor()
  }
}

Todas as outras respostas neste segmento usam o sistema de cores RGB ou simplesmente alteram o valor da tonalidade ou brilho do sistema HSB . Conforme explicado em detalhes neste ótimo post, a maneira correta de tornar uma cor mais clara ou mais escura é alterar seu luminancevalor. Nenhuma das outras respostas faz isso. Se você quiser fazer o certo, use minha solução ou escreva a sua própria depois de ler a postagem do blog.

Infelizmente, é um incômodo alterar qualquer um dos atributos de um UIColor por padrão . Além disso, a Apple nem suporta qualquer espaço de cores baseado em LAB como HCL na UIColorclasse (o LLAB é o luminancevalor que estamos procurando).

Usando HandyUIKit (instalá-lo via Cartago) adiciona suporte para HCL e faz a sua vida muito mais fácil :

import HandyUIKit    

let color = UIColor(red: 0.5, green: 0.5, blue: 0.5, alpha: 1.0)

// create a new UIColor object with a specific luminance (slightly lighter)
color.change(.luminance, to: 0.7)

Há também uma opção para aplicar uma alteração relativa (recomendada):

// create a new UIColor object with slightly darker color
color.change(.luminance, by: -0.2)

Observe que o HandyUIKit também adiciona outros recursos úteis da interface do usuário ao seu projeto - consulte o README no GitHub para obter mais detalhes.

Espero que ajude!

Não tenho certeza se você está procurando algum tipo de resposta Objective-C, mas com base em como as cores especificadas pelo RGBA funcionam, acho que você pode simplesmente escalar os valores RGB de acordo com um fator arbitrário para obter um "mais claro" ou sombra "mais escura". Por exemplo, você pode ter um azul:

[UIColor colorWithRed:0.0 green:0.0 blue:1.0 alpha:1.0];

Quer um azul mais escuro? Multiplique os valores RGB por 0,9:

[UIColor colorWithRed:0.0 green:0.0 blue:0.9 alpha:1.0];

Voila. Ou talvez você tenha uma laranja:

[UIColor colorWithRed:1.0 green:0.4 blue:0.0 alpha:1.0];

Escolha outro fator de escala, digamos, 0,8:

[UIColor colorWithRed:0.8 green:0.32 blue:0.0 alpha:1.0];

Esse é o tipo de efeito que você está procurando?

Testado no Xcode 10 com Swift 4.x para iOS 12

Comece com sua cor como um UIColor e escolha um fator de escurecimento (como um CGFloat)

let baseColor = UIColor.red
let darkenFactor: CGFloat = 2

O tipo CGColor possui um valor opcional componentsque divide a cor em RGBA (como uma matriz CGFloat com valores entre 0 e 1). Você pode reconstruir um UIColor usando valores RGBA retirados do CGColor e manipulá-los.

let darkenedBase = UIColor(displayP3Red: startColor.cgColor.components![0] / darkenFactor, green: startColor.cgColor.components![1] / darkenFactor, blue: startColor.cgColor.components![2] / darkenFactor, alpha: 1)

Neste exemplo, cada uma das valusas RGB foi dividida por 2, deixando a cor meio escura como era antes. O valor alfa permaneceu o mesmo, mas você pode aplicar o fator mais escuro no valor alfa, em vez do RGB.

Swift 5

extension UIColor {

func lighter(by percentage:CGFloat=30.0) -> UIColor? {
    return self.adjust(by: abs(percentage) )
}

func darker(by percentage:CGFloat=30.0) -> UIColor? {
    return self.adjust(by: -1 * abs(percentage) )
}
func adjust(by percentage:CGFloat=30.0) -> UIColor? {
    var r:CGFloat=0, g:CGFloat=0, b:CGFloat=0, a:CGFloat=0;
    if(self.getRed(&r, green: &g, blue: &b, alpha: &a)){
        return UIColor(red: min(r + percentage/100, 1.0),
                       green: min(g + percentage/100, 1.0),
                       blue: min(b + percentage/100, 1.0),
                       alpha: a)
    }else{
        return nil


     }
    }
}

Idealmente, as funções devem ser encapsuladas dentro de uma UIColorextensão chamada UIColor+Brightness.swift, e ter um brilho configurável - veja o exemplo abaixo:

import UIKit

extension UIColor {

  func lighterColorWithBrightnessFactor(brightnessFactor:CGFloat) -> UIColor {
    var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0
    if self.getRed(&r, green:&g, blue:&b, alpha:&a) {
      return UIColor(red:min(r + brightnessFactor, 1.0),
        green:min(g + brightnessFactor, 1.0),
        blue:min(b + brightnessFactor, 1.0),
        alpha:a)
    }
    return UIColor()
  }

}

Eu processo células coloridas com base em um valor de status:

Para isso, escrevi uma extensão rápida com base em algum código objc antigo, depois que recebi um erro usando a sugestão do CryingHippo:

extension UIColor{

    func darker(darker: CGFloat) -> UIColor{

        var red: CGFloat = 0.0
        var green: CGFloat = 0.0
        var blue: CGFloat = 0.0

        if self.colorSpace == UIColorSpace.genericGrayColorSpace(){

            red =  whiteComponent - darker
            green = whiteComponent - darker
            blue  = whiteComponent - darker
        } else {
            red = redComponent - darker
            green = greenComponent - darker
            blue = blueComponent - darker
        }

        if red < 0{
            green += red/2
            blue += red/2
        }

        if green < 0{
            red += green/2
            blue += green/2
        }

        if blue < 0{
            green += blue/2
            red += blue/2
        }

        return UIColor(
            calibratedRed: red,
            green: green,
            blue: blue,
            alpha: alphaComponent
        )
    }

    func lighter(lighter: CGFloat) -> UIColor{
        return darker(-lighter)
    }
}

O mesmo funciona NSColortambém. Simplesmente substitua UIColorpor NSColor.

Aqui está uma categoria UIColor que também permite controle sobre a quantidade de alteração de cor.

- (UIColor *)lighterColorWithDelta:(CGFloat)delta
{
    CGFloat r, g, b, a;
    if ([self getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MIN(r + delta, 1.0)
                               green:MIN(g + delta, 1.0)
                                blue:MIN(b + delta, 1.0)
                               alpha:a];
    return nil;
}

- (UIColor *)darkerColorWithDelta:(CGFloat)delta
{
    CGFloat r, g, b, a;
    if ([self getRed:&r green:&g blue:&b alpha:&a])
        return [UIColor colorWithRed:MAX(r - delta, 0.0)
                               green:MAX(g - delta, 0.0)
                                blue:MAX(b - delta, 0.0)
                               alpha:a];
    return nil;
}

Uma extensão Swift baseada na resposta @Sebyddd:

import Foundation
import UIKit

extension UIColor{
    func colorWith(brightness: CGFloat) -> UIColor{
        var r:CGFloat = 0, g:CGFloat = 0, b:CGFloat = 0, a:CGFloat = 0

        if getRed(&r, green: &g, blue: &b, alpha: &a){
            return UIColor(red: max(r + brightness, 0.0), green: max(g + brightness, 0.0), blue: max(b + brightness, 0.0), alpha: a)
        }

        return UIColor()
    }
}

para cores mais escuras, isso é o mais simples: theColor = [theColor shadowWithLevel: s]; //s.0.0 a 1.0