Obtenha cores ligeiramente mais claras e mais escuras da UIColor

144

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.

CoreCode
fonte
1
"gradiente" implica que uma parte da sua imagem será um tom da cor, enquanto outra parte será um tom mais escuro ou mais claro. Essa é outra maneira de definir o que você deseja fazer?
Michael Dautermann
2
Dê uma olhada nesta biblioteca github.com/yannickl/DynamicColor
onmyway133
Swift usando saturação de tonalidade e leveza stackoverflow.com/a/30012117/2303865
Leo Dabus 21/03

Respostas:

279
- (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
Lukas Kubanek
fonte
2
Por que usar RGB quando você pode fazer o mesmo com matiz, saturação, brilho e depois reconstruir a cor com o brilho alterado?
Jrturton 22/07
2
Eu mesmo tentei a versão HSB e ela não funcionou como esperado. Apesar da getHue:saturation:brightnessassinatura do UIKit, parece que funciona com HSV em vez de HSB. Alterar o brilho (portanto, o valor) nesse contexto não funcionará. Por exemplo, o vermelho puro (rgb (255,0,0)) terá um brilho / valor de 1, tornando impossível a iluminação através do brilho. Acabei trabalhando com alterações nos valores RGB.
Rchampourlier
2
Eu acho que há algo confuso na sua resposta: você segue as duas abordagens (uma com RGB e outra com HSB para a versão da categoria), que não têm o mesmo resultado ... E isso pode ser uma questão de o que significa: clarear é realmente para mim fazer a cor tender para o branco (escurecer para o preto), enquanto alterar o brilho / valor o torna mais forte (resp. mais claro).
Rchampourlier
4
Este método falhará se eles forem usados ​​em tons de cinza. getHue:saturation:brightness:alpharetornará FALSE.
Matthieu Riegler 14/05
2
Eu me pergunto por que essa é a resposta aceita, pois as duas soluções sugeridas estão incorretas . Ambos apenas mudam valores teóricos que pouco têm a ver com o que os seres humanos percebem como cores "mais claras" ou "mais escuras". Eu recomendo a leitura deste ótimo post (link curto: goo.gl/qqgk9V) para entender o que quero dizer. Explica que o luminancevalor do espaço de cores do LAB é o verdadeiro com o qual você deve se preocupar ao tornar as cores mais claras / mais escuras. Veja minha resposta sobre como você pode usá-lo e resolver esse problema da maneira certa.
Jeehut
59

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:

Gráfico de cores HSV

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;
}
Aviel Gross
fonte
Em relação a tornar as cores mais claras: obtive o melhor resultado reduzindo a saturação E aumentando o brilho / valor. Essa resposta funciona muito bem para as cores "em cima" da torta na imagem. Mas a maioria das cores vai cair em algum lugar "dentro" da torta. Trazê-los para mais perto do branco exige movê-los "para cima" também (aumentando o valor).
pejalo
Aumentar o valor pode parecer funcionar, mas não será a funcionalidade "principal" de "obter uma cor mais clara". Da mesma forma, para obter uma cor mais escura, a abordagem correta seria apenas para diminuir o "Valor" e deixar a saturação do jeito que está ...
Aviel Gross
38

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:

insira a descrição da imagem aqui

ChoroHippo
fonte
Eu recebi um erro: -getHue: saturação: brilho: alfa: não é válido para o NSColor NSCalibratedWhiteColorSpace 0 1; precisa primeiro converter o espaço de cores.
Besi
2
Corrija-o adicionando: let color = usingColorSpaceName(NSCalibratedRGBColorSpace) e substituindo a getHuechamada por colorida:color?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
Oskar
Falta à função um valor _antes da palavra. Deveria serprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {
Codemonk
Sugiro adicionar a sugestão de @Oskar à resposta. Isso corrigiu uma falha de tempo de execução para mim.
Besi
29

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

Exemplos Mais escuros e mais claros

FredericP
fonte
Eu acho que esta é a melhor aplicação, sem recorrer a uma biblioteca externa que implementa o espaço de cor HSL
gog
24

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()
}
Sebyddd
fonte
1
Essa é uma boa resposta, exceto que seria mais conveniente se fosse declarada como uma extensão da classe UIColor simplesmente como var darker: UIColorpor exemplo.
Bruno Philipe
13

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.

Martin R
fonte
Não é o HSL, mas o HSB é bom: developer.apple.com/library/ios/documentation/uikit/reference/… :
jrturton
8
A diferença entre o modelo de cores HSL e HSB (às vezes também chamado de HSV) é que no HSB L = 1,0 corresponde à cor pura, enquanto no HSL L = 1,0 corresponde ao branco e L = 0,5 à cor pura. Como o pôster original pediu, por exemplo, uma maneira de tornar a cor azul (RGB = 0/0/1) mais clara, acho que o HSL é mais flexível.
Martin R
6

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.

Terminus
fonte
5

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()
Hemang
fonte
2

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.

Matthieu Riegler
fonte
2

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()
  }
}
Justin Levi Winter
fonte
2

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!

Jeehut
fonte
Para o meu aplicativo, desenho rotas em mapas. Eu queria desenhar a rota com uma linha interna de uma cor com 100% de brilho e a borda com uma variante mais escura dessa cor. Como a linha interna já tinha 100% de brilho, nenhum dos métodos funcionou. Também alterar a luminância como mencionado acima não funcionou. No entanto, reduzir o brilho usando essa extensão muito boa fez o truque para mim. 'color.change (.brightness, por: -0.5)' Esta extensão é muito flexível em seu uso e tem muitas opções. Eu recomendo se, especialmente se você tiver um aplicativo com vários temas ou paletas de cores.
guido
1

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?

ravron
fonte
Ok Sim, isso é metade do que eu preciso. Existe uma maneira de obter uma cor mais clara, em seguida, quando o azul é 1 (Max)
CoreCode
@ CoreCode não, na verdade não. A menos que você deseje alterar o tamanho da tela do dispositivo :) Veja minha resposta.
1

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.

Microbob
fonte
1

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


     }
    }
}
Alfi
fonte
0

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

}
Zorayr
fonte
0

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

status-images

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.

Besi
fonte
0

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;
}
Blago
fonte
0

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()
    }
}
Balázs Vincze
fonte
-1

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

Jiulong Zhao
fonte
Este método está disponível apenas no NSColor, não no UIColor.
Seguindo