Uzyskaj nieco jaśniejszy i ciemniejszy kolor dzięki UIColor


144

Chciałem móc zamienić dowolny kolor UIColor w gradient. Zamierzam to zrobić, używając Core Graphics do narysowania gradientu. To, co próbuję zrobić, to uzyskać kolor, powiedzmy:

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

i uzyskaj UIColor, który jest o kilka odcieni ciemniejszy i kilka odcieni jaśniejszy. Czy ktoś wie, jak to zrobić? Dziękuję Ci.


1
„gradient” oznacza, że ​​jedna część obrazu będzie miała jeden odcień koloru, podczas gdy inna część będzie ciemniejsza lub jaśniejsza. Czy to inny sposób definiowania tego, co chcesz zrobić?
Michael Dautermann

2
Spójrz na tę bibliotekę github.com/yannickl/DynamicColor
onmyway133

Swift stosując odcień nasycenie i lekkości stackoverflow.com/a/30012117/2303865
Leo Dabus

Odpowiedzi:


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

Użyj tego w ten sposób:

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

EDYCJA : jak zauważył @Anchu Chimala, dla maksymalnej elastyczności metody te powinny zostać wdrożone jako kategoria UIColor. Ponadto, zgodnie z pomysłem @ Riley'a, może być lepszym pomysłem, aby kolor był proporcjonalnie ciemniejszy lub jaśniejszy, zamiast dodawać lub odejmować wartości stałe. Jak zauważył @jrturton, nie ma potrzeby manipulowania komponentami RGB; lepiej zmodyfikować samą właściwość jasności. W sumie:

@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

2
Po co używać RGB, skoro można zrobić to samo z odcieniem, nasyceniem, jasnością, a następnie po prostu odbudować kolor ze zmienioną jasnością?
jrturton

2
Sam próbowałem z wersją HSB i nie działało to zgodnie z oczekiwaniami. Pomimo getHue:saturation:brightnesspodpisu UIKit wygląda na to, że działa z HSV zamiast HSB. Zmiana jasności (a więc w rzeczywistości wartości) w tym kontekście nie zadziała. Na przykład czysty czerwony (rgb (255,0,0)) będzie miał jasność / wartość 1, co uniemożliwi rozjaśnienie przez jasność. Skończyło się na tym, że zamiast tego pracowałem ze zmianami wartości RGB.
rchampourlier

2
Myślę, że w Twojej odpowiedzi jest coś zagmatwanego: wybierasz dwa podejścia (jedno z RGB, a drugie z HSB dla wersji kategorii), które nie dają tego samego wyniku ... I to może być kwestia znaczenie: rozjaśnienie jest dla mnie rzeczywiście sprawiające, że kolor staje się biały (ciemnieje do czerni), podczas gdy zmiana jasności / wartości sprawia, że ​​jest on silniejszy (lub jaśniejszy).
rchampourlier

4
Te metody zawiodą, jeśli zostaną użyte na szarych odcieniach. getHue:saturation:brightness:alphazwróci FALSE.
Matthieu Riegler

2
Zastanawiam się, dlaczego jest to akceptowana odpowiedź, ponieważ oba sugerowane rozwiązania są nieprawidłowe . Obie zmieniają jedynie wartości teoretyczne, które mają niewiele wspólnego z tym, co ludzie postrzegają jako „jaśniejsze” lub „ciemniejsze” kolory. Polecam przeczytanie tego świetnego posta (shortlink: goo.gl/qqgk9V), aby zrozumieć, o co mi chodzi. Wyjaśnia, że luminancewartość przestrzeni kolorów LAB jest prawdziwa, o którą należy się troszczyć przy rozjaśnianiu / przyciemnianiu kolorów. Zobacz moją odpowiedź na jaki można z niego skorzystać i rozwiązać ten problem we właściwy sposób.
Jeehut

59

TL; DR:

Szybki:

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

Stosowanie:

let lightColor = somethingDark.lighterColor

Cel 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 swoim komentarzu do @ user529758 (zaakceptowana 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 zasadniczo zaczyna się od czerni, a kończy na czystym kolorze ...

Zasadniczo Jasność (Wartość) sprawia, że ​​kolor jest mniej lub bardziej zbliżony do czerni, podczas gdy nasycenie sprawia, że ​​jest mniej lub bardziej bliższy bieli ...

Jak widać tutaj:

Wykres kolorów HSV

Tak więc rozwiązaniem, aby uczynić kolor faktycznie jaśniejszym (tj. Bliższym bieli ...) będzie zmniejszenie wartości nasycenia , co daje następujące 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;
}

Jeśli chodzi o rozjaśnianie kolorów: najlepszy wynik uzyskałem, zmniejszając nasycenie ORAZ zwiększając jasność / wartość. Ta odpowiedź świetnie sprawdza się w przypadku kolorów „na wierzchu” ciasta na obrazku. Ale większość kolorów spadnie gdzieś „wewnątrz” ciasta. Przybliżenie ich do bieli wymaga również przesunięcia ich „w górę” (zwiększenie wartości).
pejalo

Zwiększanie wartości może wydawać się działać, ale nie będzie to „podstawowa” funkcja „uzyskaj jaśniejszy kolor”. W ten sam sposób, aby uzyskać ciemniejszy kolor, właściwym podejściem byłoby tylko zmniejszenie „wartości” i pozostawienie nasycenia takim, jakie jest ...
Aviel Gross,

38

Swift uniwersalne rozszerzenie dla iOS i OS X , korzystając 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

    }

}

Stosowanie :

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)

LUB (z wartościami domyślnymi):

color.lighter()
color.darker()

Próbka:

wprowadź opis obrazu tutaj


Wystąpił błąd: -getHue: nasycenie: jasność: alpha: nieważne dla NSColor NSCalibratedWhiteColorSpace 0 1; trzeba najpierw przekonwertować przestrzeń kolorów.
Besi

2
Napraw to, dodając: let color = usingColorSpaceName(NSCalibratedRGBColorSpace) a następnie zastępując getHuewywołanie wywołaniem koloru:color?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
Oskar

W funkcji brakuje _przed słowem kwota. Powinno byćprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {
Codemonk

Proponuję dodać do odpowiedzi sugestię @Oskara. To naprawiło dla mnie awarię środowiska wykonawczego.
Besi,

29

Chciałem tylko dać ten 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 taki sam wynik, AFAIK, niż wybranie koloru w gradiencie „kolor do białego” lub „kolor do czerni” przy x% rozmiaru 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 kolorami

Przykłady Ciemniej i jaśniej


Myślę, że to najlepsza implementacja bez uciekania się do zewnętrznej biblioteki, która implementuje przestrzeń kolorów HSL
gog

24

Rozwiązanie użytkownika529758 w 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()
}

1
To dobra odpowiedź, z tym że byłoby wygodniej, gdyby zostało zadeklarowane jako rozszerzenie klasy UIColor, tak jak var darker: UIColorna przykład.
Bruno Philipe

13

Jeśli konwertujesz kolor RGB na model kolorów HSL , możesz zmieniać składową L = jasności od L = 0,0 (czarny) przez L = 0,5 (kolor naturalny) do L = 1,0 (biały). UIColornie obsługuje HSL bezpośrednio, ale istnieje wzór na konwersję RGB <-> HSL.



8
Różnica między modelem koloru HSL i HSB (czasami nazywanym również HSV) polega na tym, że w HSB L = 1,0 odpowiada kolorowi czystemu, podczas gdy w HSL L = 1,0 odpowiada barwie białej, a L = 0,5 barwie czystej. Ponieważ oryginalny plakat prosił np. O sposób na rozjaśnienie koloru niebieskiego (RGB = 0/0/1), myślę, że HSL jest bardziej elastyczny.
Martin R

6

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

W szczególności ma funkcję rozjaśniania w ramach implementacji HSL: (UIColor *)lighten:(CGFloat)amount- co działa doskonale.


5

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

Stosowanie:

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

2

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:alphanie powiedzie się (i wróci false), gdy zostanie wywołany w szarym odcieniu, dlatego będziesz musiał użyć getWhite:alpha.


2

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

2

Wszystkie inne odpowiedzi w tym wątku wykorzystują system kolorów RGB lub po prostu zmieniają odcień lub wartość jasności systemu HSB . Jak wyjaśniono szczegółowo w tej wielkiej blogu pisać o prawidłowy sposób dokonywania kolor jaśniejszy lub ciemniejszy jest, aby zmienić jej luminancewartość. Żadna z pozostałych odpowiedzi tego nie robi. Jeśli chcesz to zrobić dobrze, skorzystaj z mojego rozwiązania lub napisz własne po przeczytaniu wpisu na blogu.


Niestety domyślna zmiana któregokolwiek z atrybutów UIColor jest dość kłopotliwa . Ponadto Apple nie obsługuje nawet żadnej przestrzeni kolorów opartej na LAB, takiej jak HCL w tej klasie ( in LAB to wartość, której szukamy).UIColorLluminance

Korzystanie z HandyUIKit (zainstaluj za pośrednictwem Carthage) dodaje obsługę HCL i znacznie ułatwia życie :

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ędnej zmiany (zalecane):

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

Zwróć uwagę, że HandyUIKit dodaje również inne przydatne funkcje interfejsu użytkownika do twojego projektu - sprawdź jego README w GitHub, aby uzyskać więcej informacji.

Mam nadzieję, że to pomoże!


W mojej aplikacji rysuję trasy na mapach. Trasę chciałem narysować wewnętrzną linią koloru o 100% jasności i obramowaniem ciemniejszym wariantem tego koloru. Ponieważ linia wewnętrzna miała już 100% jasności, żadna z metod nie zadziałała. Również zmiana luminancji jak wspomniana powyżej nie załatwiła sprawy. Jednak zmniejszenie jasności za pomocą tego bardzo fajnego rozszerzenia załatwiło sprawę. „color.change (.brightness, by: -0,5)” To rozszerzenie jest bardzo elastyczne w użyciu i ma wiele opcji. Polecam, zwłaszcza jeśli masz aplikację z kilkoma motywami lub paletami kolorów.
guido

1

Nie jestem pewien, czy szukasz odpowiedzi typu Objective-C, ale na podstawie tego, 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];

Chcesz mieć ciemniejszy niebieski? Pomnóż wartości RGB przez 0,9:

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

Voila. A może masz pomarańczę:

[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];

Czy tego rodzaju efektu szukasz?


Ok, tak, to połowa tego, czego potrzebuję. Czy jest sposób na uzyskanie jaśniejszego koloru niż wtedy, gdy niebieski wynosi 1 (maks.)
CoreCode

@CoreCode no, nie bardzo. Chyba, że ​​chcesz zmienić grubość ekranu urządzenia :) Zobacz moją odpowiedź.

1

Przetestowano w Xcode 10 ze Swift 4.x dla iOS 12

Zacznij od koloru jako UIColor i wybierz współczynnik zaciemnienia (jako CGFloat)

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

Typ CGColor ma opcjonalną wartość, componentsktóra rozbija kolor na RGBA (jako tablica CGFloat z wartościami od 0 do 1). Następnie można zrekonstruować UIColor przy użyciu 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 wartość RGB została podzielona przez 2, dzięki czemu kolor był o połowę mniejszy niż wcześniej. Wartość alfa pozostała taka sama, ale można alternatywnie zastosować współczynnik zaciemnienia do wartości alfa zamiast RGB.


1

Szybki 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


     }
    }
}

0

W idealnym przypadku funkcje powinny być umieszczone w UIColorrozszerzeniu 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()
  }

}

0

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

obrazy statusu

W tym celu napisałem szybkie rozszerzenie w oparciu o stary kod objc po tym, jak wystąpił błąd, korzystając z 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 NSColorrównież w przypadku. Wystarczy wymienić UIColorz NSColor.


0

Oto kategoria UIColor, która pozwala również kontrolować ilość zmian koloru.

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

0

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

-1

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


Ta metoda jest dostępna tylko w NSColor, a nie w UIColor.
followben
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.