TL; DR:

Swift:

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

Użycie:

let lightColor = somethingDark.lighterColor

Objective-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 miał rację w komentarzu do @user529758 (przyjęta odpowiedź) - rozwiązania HSB (lub HSV) I RGB dają zupełnie inne wyniki. RGB po prostu dodaje (lub przybliża kolor) biel, a rozwiązanie HSB przybliża kolor do krawędzi w skali Brigtness - która w zasadzie zaczyna się od czerni, a kończy na czystym kolorze...

Zasadniczo Jasność (Wartość) sprawia, że kolor jest mniej lub bardziej zbliżony do czerni, gdzie nasycenie sprawia, że jest mniej lub bardziej zbliżony do bieli...

Jak widać tutaj:

Więc rozwiązanie, aby kolor rzeczywiście jaśniejszy (tj. bliżej białego...) będzie mieć wartość nasycenia mniejszą , co daje takie rozwiązanie:

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

Swift universal extension for iOS and OS X, using 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

    }

}

Użycie:

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)

OR (z wartościami domyślnymi):

color.lighter()
color.darker()

Próbka:

Chciałem tylko dać taki sam wynik, w RGB, niż

• umieszczenie koloru z alfa x% na białym tle w celu rozjaśnienia
• umieszczenie koloru z alfa x% na czarnym tle w celu przyciemnienia

Co daje ten sam wynik, AFAIK, niż wybranie koloru w gradiencie "kolor na biel" lub "kolor na czerń", przy x % wielkości gradientu.

W tym celu matematyka jest prosta:

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

Oto przykłady z niektórymi kolory

rozwiązanie user529758 w języku Swift:

Ciemniejszy kolor:

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

Jaśniejszy kolor:

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

Jeśli przekonwertujesz kolor RGB na model kolorów HSL , możesz zmienić Składnik l = lekkość z L = 0,0 (Czarny) przez L = 0,5 (kolor naturalny) na L = 1,0 (biały) . UIColor nie można obsługiwać HSL bezpośrednio, ale istnieją formuły do konwersji RGB HSL.

Żadne z opublikowanych rozwiązań całkiem nie działało dla wszystkich kolorów i odcieni, ale wtedy natknąłem się na tę bibliotekę, która dostarcza zestaw bardzo dobrze zaimplementowanych rozszerzeń do UIColor.

W szczególności posiada funkcję lighten jako część implementacji HSL: (UIColor *)lighten:(CGFloat)amount - która działa doskonale.

Sebyddd rozwiązanie jako rozszerzenie:

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

Użycie:

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

Jeśli chcesz, aby rozwiązanie user529758 działało z odcieniami szarości (jak [UIColor lightGrayColor] lub [UIColor darkGrayColor], Musisz to poprawić w ten sposób:

- (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 nie powiedzie się (i zwróci false), gdy zostanie wywołany szary odcień, dlatego musisz użyć getWhite:alpha.

Wszystkie inne odpowiedzi w tym wątku używająalbo systemu kolorów RGB lub po prostu zmieniająwartość barwy lub jasności systemu HSB . Jak wyjaśniono szczegółowo w this great blog post poprawnym sposobem uczynienia koloru jaśniejszego lub ciemniejszego jest zmiana jego wartości luminance. Żadna z innych odpowiedzi tego nie robi. Jeśli chcesz zrobić to dobrze, to Użyj mojego rozwiązania lub napisz własne po przeczytaniu bloga poczta.

Niestety jest to dość kłopotliwe , aby zmienić dowolny z atrybutów UIColor domyślnie . Ponadto Apple nie obsługuje nawet żadnej przestrzeni kolorów opartej na laboratorium, takiej jak HCL w klasie UIColor (L in LAB to wartość luminance, której szukamy).

Za pomocą HandyUIKit (zainstaluj go przez Kartaginę) dodaje obsługę HCL i sprawia, że Twoje życie jest dużo łatwiejsze :

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)

Istnieje również możliwość zastosowania względnego zmiana (zalecane):

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

Zauważ, że HandyUIKit dodaje również kilka innych przydatnych funkcji interfejsu do twojego projektu – sprawdź jego README na GitHub, aby uzyskać więcej szczegółów.

Zastrzeżenie: jestem autorem HandyUIKit.

Uicolor przedłużanie i mocowanie lighterColorForColor

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

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

Nie jestem pewien, czy szukasz jakiejś odpowiedzi Objective-C, ale w oparciu o to, jak działają kolory określone przez RGBA, myślę, że możesz po prostu przeskalować wartości RGB zgodnie z dowolnym czynnikiem, aby uzyskać "jaśniejszy" lub "ciemniejszy" odcień. Na przykład możesz mieć niebieski:

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

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

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

Wybierz inny współczynnik skali, powiedzmy 0.8:

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

Jest to rodzaj efekt, którego szukasz?

Testowane w Xcode 10 z Swift 4.x Dla iOS 12

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

Typ CGColor ma opcjonalną wartość components, która rozbija kolor na RGBA (jako tablicę CGFloat o wartościach od 0 do 1). Następnie można zrekonstruować UIColor używając wartości rgba pobranych z CGColor i manipulować nimi.

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

W tym przykładzie każda z wartości RGB została podzielona przez 2, dzięki czemu kolor jest w połowie tak mroczne jak było wcześniej. Wartość alfa pozostała taka sama, ale można alternatywnie zastosować współczynnik przyciemnienia na wartości alfa zamiast RGB.

Idealnie, funkcje powinny być zamknięte wewnątrz rozszerzenia UIColor o nazwie, UIColor+Brightness.swift i mieć konfigurowalną jasność-patrz przykład poniżej:

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

}

Renderuję kolorowe komórki na podstawie wartości statusu:

W tym celu napisałem szybkie rozszerzenie oparte na Starym kodzie objc po tym, jak dostałem błąd używając sugestii 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)
    }
}

To samo działa również dla NSColor. Po prostu zamień UIColor na NSColor.

Tutaj znajduje się Kategoria UIColor, która umożliwia również kontrolę nad ilością zmian kolorów.

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

szybkie rozszerzenie oparte na odpowiedzi @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()
    }
}

Dla ciemniejszego koloru jest to najprostszy: theColor = [theColor shadowWithLevel: s]; //s:0.0 do 1.0