Je cherchais à transformer n'importe quel UIColor en dégradé. La façon dont j'ai l'intention de le faire est d'utiliser Core Graphics pour dessiner un dégradé. Ce que j'essaie de faire, c'est d'obtenir une couleur, disons:

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

et obtenez un UIColor qui est quelques nuances plus foncées et quelques nuances plus claires. Est-ce que quelqu'un sait comment faire ça? Je vous remercie.

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

Utilisez-le comme ceci:

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

EDIT : comme @Anchu Chimala l'a souligné, pour une flexibilité maximale, ces méthodes devraient être implémentées en tant que catégorie UIColor. De plus, d'après l'idée de @ Riley, il peut être préférable de rendre la couleur proportionnellement plus sombre ou plus claire au lieu d'ajouter ou de soustraire des valeurs constantes. Comme @jrturton l'a souligné, il n'est pas nécessaire de manipuler les composants RVB; il est préférable de modifier la propriété de luminosité elle-même. En tout:

@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:

Rapide:

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

Usage:

let lightColor = somethingDark.lighterColor

Objectif 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 avait raison dans son commentaire à @ user529758 (La réponse acceptée) - Les solutions HSB (ou HSV) et RVB donnent des résultats complètement différents. RVB ajoute simplement (ou rapproche la couleur du) blanc, et la solution HSB rapproche la couleur du bord de l'échelle de Brigtness - qui commence essentiellement par le noir et se termine par la couleur pure ...

Fondamentalement, la luminosité (valeur) rend la couleur plus ou moins proche du noir, où la saturation la rend moins ou plus proche du blanc ...

Comme vu ici:

Donc , la solution pour rendre une couleur plus claire en fait ( par exemple plus proche de blanc ...) sera de rendre sa valeur de saturation plus petite , ce qui cette solution:

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

Extension universelle Swift pour iOS et OS X , utilisant 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

    }

}

Utilisation:

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 (avec les valeurs par défaut):

color.lighter()
color.darker()

Échantillon :

Je voulais juste donner le même résultat, en RVB, que

• placer la couleur avec alpha x% sur un fond blanc pour éclaircir
• placer la couleur avec alpha x% sur un fond noir pour assombrir

Ce qui donne le même résultat, AFAIK, que de choisir la couleur dans un dégradé «couleur au blanc» ou «couleur au noir», à x% de la taille du dégradé.

Pour cela, le calcul est simple:

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

Voici des exemples avec quelques couleurs

La solution de user529758 dans Swift:

Couleur plus foncée:

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

Couleur plus claire:

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

Si vous convertissez la couleur RVB en modèle de couleur TSL, vous pouvez faire varier la composante L = luminosité de L = 0,0 (noir) sur L = 0,5 (couleur naturelle) à L = 1,0 (blanc). UIColorne peut pas gérer directement HSL, mais il existe une formule pour convertir RVB <-> HSL.

Aucune des solutions posté tout à fait travaillé pour toutes les couleurs et les nuances, mais je suis tombée sur cette bibliothèque qui fournit un ensemble d'extensions très bien mis en œuvre pour UIColor.

Plus précisément, il a une fonction allégée dans le cadre de sa mise en œuvre HSL: (UIColor *)lighten:(CGFloat)amount- qui fonctionne parfaitement.

Sebyddd solution comme extension:

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

Usage:

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

Si vous voulez que la solution de user529758 fonctionne avec des nuances de gris (comme [UIColor lightGrayColor]ou [UIColor darkGrayColor] vous devez l'améliorer comme ça:

- (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:alphaéchoue (et retourne false) lorsqu'il est appelé sur une nuance grise, vous devrez donc utiliser getWhite:alpha.

Extension UIColor et briquet de fixationColorForColor

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

Toutes les autres réponses de ce fil utilisent le système de couleurs RVB ou modifient simplement la teinte ou la valeur de luminosité du système HSB . Comme expliqué en détail dans cet excellent article de blog, la bonne façon de rendre une couleur plus claire ou plus foncée est de changer sa luminancevaleur. Aucune des autres réponses ne fait cela. Si vous voulez bien faire les choses, utilisez ma solution ou écrivez la vôtre après avoir lu le billet de blog.

Malheureusement, il est assez compliqué de changer l'un des attributs d'un UIColor par défaut . De plus, Apple ne prend même pas en charge les espaces colorimétriques basés sur LAB comme HCL dans la UIColorclasse (la valeur Ldans LAB est la luminancevaleur que nous recherchons).

En utilisant HandyUIKit ( l' installer via Carthage) ajoute le support pour HCL et rend votre vie beaucoup plus facile :

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)

Il existe également une option pour appliquer un changement relatif (recommandé):

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

Notez que HandyUIKit ajoute également d' autres fonctionnalités d'interface utilisateur pratiques dans votre projet - consultez son README sur GitHub pour plus de détails.

J'espère que ça aide!

Je ne sais pas si vous recherchez une sorte de réponse Objective-C, mais en fonction du fonctionnement des couleurs spécifiées par RGBA, je pense que vous pouvez simplement mettre à l'échelle les valeurs RVB en fonction d'un facteur arbitraire pour obtenir un "plus clair" ou teinte "plus foncée". Par exemple, vous pourriez avoir un bleu:

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

Envie d'un bleu plus foncé? Multipliez les valeurs RVB par 0,9:

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

Voila. Ou peut-être avez-vous une orange:

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

Choisissez un autre facteur d'échelle, disons 0,8:

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

Est-ce le genre d'effet que vous recherchez?

Testé dans Xcode 10 avec Swift 4.x pour iOS 12

Commencez avec votre couleur comme UIColor et choisissez un facteur d'assombrissement (comme CGFloat)

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

Le type CGColor a une valeur facultative componentsqui décompose la couleur en RGBA (sous forme de tableau CGFloat avec des valeurs comprises entre 0 et 1). Vous pouvez ensuite reconstruire un UIColor en utilisant des valeurs RGBA extraites du CGColor et les manipuler.

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

Dans cet exemple, chacune des valeurs RVB a été divisée par 2, ce qui rend la couleur deux fois moins sombre qu'auparavant. La valeur alpha est restée la même, mais vous pouvez également appliquer le facteur d'assombrissement sur la valeur alpha plutôt que sur RVB.

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


     }
    }
}

Idéalement, les fonctions doivent être encapsulées dans une UIColorextension appelée UIColor+Brightness.swift, et avoir une luminosité configurable - voir l'exemple ci-dessous:

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

}

Je rend les cellules colorées en fonction d'une valeur de statut:

Pour cela, j'ai écrit une extension rapide basée sur un ancien code objc après avoir reçu une erreur en utilisant la suggestion de 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)
    }
}

La même chose fonctionne NSColorégalement. Remplacez simplement UIColorpar NSColor.

Voici une catégorie UIColor qui permet également de contrôler la quantité de changement de couleur.

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

Une extension Swift basée sur la réponse @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()
    }
}

pour une couleur plus foncée, c'est la plus simple: theColor = [theColor shadowWithLevel: s]; //s:0.0 à 1.0