Ich wollte in der Lage sein, jede UIColor in einen Farbverlauf umzuwandeln. Die Absicht, dies zu tun, besteht darin, mithilfe von Core Graphics einen Farbverlauf zu zeichnen. Ich versuche, eine Farbe zu bekommen, sagen wir:

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

und erhalten Sie eine UIColor, die einige Nuancen dunkler und einige Nuancen heller ist. Weiß jemand, wie man das macht? Danke dir.

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

Verwenden Sie es so:

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

EDIT : als @Anchu Chimala wies darauf hin, für ein Maximum an Flexibilität, sollten diese Methoden als UIColor Kategorie implementiert werden. Nach der Idee von @ Riley ist es möglicherweise besser, die Farbe proportional dunkler oder heller zu machen, anstatt konstante Werte zu addieren oder zu subtrahieren. Wie @jrturton hervorhob, ist es nicht erforderlich, die RGB-Komponenten zu manipulieren. Es ist besser, die Helligkeitseigenschaft selbst zu ändern. Alles in allem:

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

Schnell:

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

Verwendung:

let lightColor = somethingDark.lighterColor

Ziel 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 hatte Recht mit seinem Kommentar zu @ user529758 (Die akzeptierte Antwort) - Die Lösungen HSB (oder HSV) und RGB liefern völlig unterschiedliche Ergebnisse. RGB fügt nur Weiß hinzu (oder bringt die Farbe näher an Weiß), und die HSB-Lösung bringt die Farbe näher an den Rand der Brigtness-Skala - die im Grunde mit Schwarz beginnt und mit der reinen Farbe endet ...

Grundsätzlich macht die Helligkeit (Wert) die Farbe weniger oder mehr näher an Schwarz, während die Sättigung sie weniger oder mehr näher an Weiß bringt ...

Wie hier zu sehen:

Die Lösung, um eine Farbe tatsächlich heller zu machen (dh näher an Weiß ...), besteht darin, den Sättigungswert zu verkleinern , was zu folgender Lösung führt:

- (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-Erweiterung für iOS und OS X , mit 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

    }

}

Verwendung :

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)

ODER (mit den Standardwerten):

color.lighter()
color.darker()

Stichprobe :

Ich wollte nur das gleiche Ergebnis in RGB liefern als

• Platzieren Sie die Farbe mit Alpha x% über einem weißen Hintergrund, um sie aufzuhellen
• Platzieren Sie die Farbe mit Alpha x% über einem schwarzen Hintergrund, um sie abzudunkeln

Dies ergibt das gleiche Ergebnis, AFAIK, als die Auswahl der Farbe in einem Farbverlauf "Farbe zu Weiß" oder "Farbe zu Schwarz" bei x% der Verlaufsgröße.

Zu diesem Zweck ist die Mathematik einfach:

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

Hier sind Beispiele mit einigen Farben

Die Lösung von user529758 in Swift:

Dunklere Farbe:

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

Hellere Farbe:

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

Wenn Sie die RGB-Farbe in das HSL-Farbmodell konvertieren , können Sie die L = Helligkeitskomponente von L = 0,0 (schwarz) über L = 0,5 (natürliche Farbe) bis L = 1,0 (weiß) variieren. UIColorkann HSL nicht direkt verarbeiten, aber es gibt Formeln zum Konvertieren von RGB <-> HSL.

Keine der Lösungen posted recht für alle Farben und Schattierungen gearbeitet, aber dann stolperte ich über diese Bibliothek , die eine Reihe von sehr gut umgesetzt Erweiterungen UIColor bietet.

Insbesondere hat es eine Aufhellungsfunktion als Teil seiner HSL-Implementierung: (UIColor *)lighten:(CGFloat)amount- die perfekt funktioniert.

Sebyddd Lösung als Erweiterung:

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

Verwendung:

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

Wenn Sie möchten, dass die Lösung von user529758 mit Graustufen funktioniert (wie [UIColor lightGrayColor]oder [UIColor darkGrayColor] Sie müssen sie so verbessern:

- (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:alphaschlägt fehl (und kehrt zurück false), wenn ein Grauton aufgerufen wird, daher müssen Sie verwenden getWhite:alpha.

UIColor-Erweiterung und Befestigung von leichterColorForColor

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

Alle anderen Antworten in diesem Thread verwenden entweder das RGB-Farbsystem oder ändern einfach den Farbton- oder Helligkeitswert des HSB-Systems . Wie in diesem großartigen Blog-Beitrag ausführlich erläutert, besteht die richtige Art, eine Farbe heller oder dunkler zu machen, darin, ihren luminanceWert zu ändern . Keine der anderen Antworten macht das. Wenn du es richtig machen willst, dann benutze meine Lösung oder schreibe deine eigene, nachdem du den Blog-Beitrag gelesen hast .

Leider ist es ziemlich mühsam, standardmäßig eines der Attribute einer UIColor zu ändern . Außerdem unterstützt Apple in der UIColorKlasse nicht einmal einen LAB-basierten Farbraum wie HCL (der Lin LAB ist der luminanceWert, den wir suchen).

Die Verwendung von HandyUIKit (Installation über Karthago) bietet Unterstützung für HCL und erleichtert Ihnen das Leben erheblich :

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)

Es gibt auch eine Option zum Anwenden einer relativen Änderung (empfohlen):

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

Beachten Sie, dass HandyUIKit Ihrem Projekt auch einige andere praktische UI-Funktionen hinzufügt. Weitere Informationen finden Sie in der README-Datei auf GitHub .

Ich hoffe, es hilft!

Ich bin mir nicht sicher, ob Sie nach einer Art Objective-C-Antwort suchen, aber basierend auf der Funktionsweise der von RGBA angegebenen Farben können Sie die RGB-Werte einfach nach einem beliebigen Faktor skalieren, um ein "helleres" oder "heller" zu erhalten "dunkler" Schatten. Zum Beispiel könnten Sie ein Blau haben:

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

Willst du ein dunkleres Blau? Multiplizieren Sie die RGB-Werte mit 0,9:

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

Voila. Oder vielleicht hast du eine Orange:

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

Wählen Sie einen anderen Skalierungsfaktor, z. B. 0,8:

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

Ist das der Effekt, den Sie suchen?

Getestet in Xcode 10 mit Swift 4.x für iOS 12

Beginnen Sie mit Ihrer Farbe als UIColor und wählen Sie einen Verdunkelungsfaktor (als CGFloat).

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

Der Typ CGColor verfügt über einen optionalen Wert, componentsder die Farbe in RGBA aufteilt (als CGFloat-Array mit Werten zwischen 0 und 1). Anschließend können Sie eine UIColor mithilfe von RGBA-Werten aus der CGColor rekonstruieren und bearbeiten.

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

In diesem Beispiel wurde jeder RGB-Wert durch 2 geteilt, wodurch die Farbe halb so dunkel war wie zuvor. Der Alpha-Wert blieb gleich, aber Sie können alternativ den Verdunkelungsfaktor auf den Alpha-Wert und nicht auf den RGB-Wert anwenden.

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


     }
    }
}

Idealerweise sollten die Funktionen in einer UIColorErweiterung mit dem Namen UIColor+Brightness.swiftund gekapselt sein und eine konfigurierbare Helligkeit aufweisen - siehe Beispiel unten:

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

}

Ich rendere farbige Zellen basierend auf einem Statuswert:

Dafür habe ich eine schnelle Erweiterung geschrieben, die auf einem alten Objektcode basiert, nachdem ich einen Fehler mit CryingHippos Vorschlag erhalten habe:

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

Das gleiche gilt auch für NSColor. Ersetzen Sie einfach UIColormit NSColor.

Hier ist eine UIColor-Kategorie, mit der Sie auch das Ausmaß der Farbänderung steuern können.

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

Eine Swift-Erweiterung basierend auf der Antwort von @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()
    }
}

Für dunklere Farben ist dies die einfachste: theColor = [theColor shadowWithLevel: s]; //s:0.0 bis 1.0