Holen Sie sich etwas hellere und dunklere Farben von UIColor

144

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.

CoreCode
quelle
1
"Farbverlauf" bedeutet, dass ein Teil Ihres Bildes einen Farbton aufweist, während ein anderer Teil einen dunkleren oder helleren Farbton aufweist. Ist dies eine andere Art zu definieren, was Sie tun möchten?
Michael Dautermann
2
Werfen
Schnelle
Leo Dabus

Antworten:

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

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
Lukas Kubanek
quelle
2
Warum RGB verwenden, wenn Sie dasselbe mit Farbton, Sättigung und Helligkeit tun können, und dann einfach die Farbe mit geänderter Helligkeit neu erstellen können?
Jrturton
2
Ich habe es selbst mit der HSB-Version versucht und es hat nicht wie erwartet funktioniert. Trotz der getHue:saturation:brightnessUnterschrift von UIKit scheint es mit HSV anstelle von HSB zu funktionieren. Das Ändern der Helligkeit (also des Werts) in diesem Kontext funktioniert nicht. Zum Beispiel hat reines Rot (rgb (255,0,0)) eine Helligkeit / einen Wert von 1, wodurch ein Aufhellen durch die Helligkeit unmöglich wird. Ich habe stattdessen mit Änderungen an RGB-Werten gearbeitet.
Rchampourlier
2
Ich denke, dass Ihre Antwort etwas Verwirrendes enthält: Sie verfolgen die beiden Ansätze (einen mit RGB und den anderen mit HSB für die Kategorieversion), die nicht das gleiche Ergebnis haben ... Und das kann eine Frage sein Das heißt: Aufhellen bedeutet für mich, dass die Farbe zum Weiß tendiert (Verdunkeln zum Schwarz), während das Ändern der Helligkeit / des Werts sie stärker macht (bzw. heller macht).
Rchampourlier
4
Diese Methode schlägt fehl, wenn sie für Graustufen verwendet wird. getHue:saturation:brightness:alphawird FALSE zurückgeben.
Matthieu Riegler
2
Ich frage mich, warum dies die akzeptierte Antwort ist, da beide vorgeschlagenen Lösungen falsch sind . Beide ändern lediglich theoretische Werte , die wenig mit dem zu tun haben, was Menschen als "hellere" oder "dunklere" Farben wahrnehmen. Ich empfehle, diesen großartigen Beitrag (Shortlink: goo.gl/qqgk9V) zu lesen, um zu verstehen, was ich meine. Dies erklärt, dass der luminanceWert des LAB-Farbraums der wahre ist, den Sie berücksichtigen sollten, wenn Sie Farben heller / dunkler machen. Sehen Sie sich meine Antwort an, wie Sie sie nutzen und dieses Problem richtig lösen können.
Jeehut
59

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:

HSV-Farbdiagramm

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;
}
Aviel Gross
quelle
Bezüglich der Aufhellung von Farben: Ich habe das beste Ergebnis erzielt, indem ich die Sättigung verringert UND die Helligkeit / den Wert erhöht habe. Diese Antwort eignet sich hervorragend für Farben "über" dem Kuchen im Bild. Aber die meisten Farben werden irgendwo "in" den Kuchen fallen. Um sie näher an Weiß zu bringen, müssen sie ebenfalls "nach oben" bewegt werden (Wertsteigerung).
Pejalo
Das Erhöhen des Werts scheint zu funktionieren, ist jedoch nicht die "Kern" -Funktionalität von "Erhalten einer helleren Farbe". Um eine dunklere Farbe zu erhalten, wäre der richtige Ansatz, nur den "Wert" zu verringern und die Sättigung so zu belassen, wie sie ist ...
Aviel Gross
38

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 :

Geben Sie hier die Bildbeschreibung ein

CryingHippo
quelle
Ich habe eine Fehlermeldung erhalten: -getHue: Sättigung: Helligkeit: Alpha: Nicht gültig für NSColor NSCalibratedWhiteColorSpace 0 1; müssen zuerst den Farbraum konvertieren.
Besi
2
let color = usingColorSpaceName(NSCalibratedRGBColorSpace)getHuecolor?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
Oskar
Der Funktion fehlt ein _vor dem Wortbetrag. Sollte seinprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {
Codemonk
Ich schlage vor, der Antwort den Vorschlag von @Oskar hinzuzufügen. Dies hat einen Laufzeitabsturz für mich behoben.
Besi
29

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

Beispiele dunkler und heller

FredericP
quelle
Ich denke, dies ist die beste Implementierung, ohne auf eine externe Bibliothek zurückzugreifen, die den HSL-Farbraum implementiert
gog
24

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()
}
Sebyddd
quelle
1
Dies ist eine gute Antwort, außer es wäre bequemer, wenn es einfach wie var darker: UIColorzum Beispiel als Erweiterung der UIColor-Klasse deklariert würde .
Bruno Philipe
13

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.

Martin R.
quelle
Nicht HSL, aber HSB ist in Ordnung: developer.apple.com/library/ios/documentation/uikit/reference/… :
jrturton
8
Der Unterschied zwischen dem HSL- und dem HSB-Farbmodell (manchmal auch als HSV bezeichnet) besteht darin, dass in HSB L = 1,0 der reinen Farbe entspricht, während in HSL L = 1,0 Weiß und L = 0,5 der reinen Farbe entspricht. Da das Originalplakat zB nach einer Möglichkeit gefragt hat, die Farbe Blau (RGB = 0/0/1) heller zu machen, denke ich, dass HSL flexibler ist.
Martin R
6

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.

Terminus
quelle
5

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

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.

Matthieu Riegler
quelle
2

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

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!

Jeehut
quelle
Für meine App zeichne ich Routen auf Karten. Ich wollte die Route mit einer inneren Linie einer Farbe mit 100% Helligkeit und dem Rand mit einer dunkleren Variante dieser Farbe zeichnen. Da die Innenlinie bereits 100% Helligkeit hatte, funktionierte keine der Methoden. Auch das Ändern der Luminanz wie oben erwähnt hat nicht funktioniert. Das Reduzieren der Helligkeit mit dieser sehr schönen Erweiterung hat mir jedoch geholfen. 'color.change (.brightness, by: -0.5)' Diese Erweiterung ist sehr flexibel in der Verwendung und bietet viele Optionen. Ich empfehle wenn, insbesondere wenn Sie eine App mit mehreren Themen oder Farbpaletten haben.
Guido
1

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?

Ravron
quelle
Ok Ja, das ist die Hälfte von dem, was ich brauche. Gibt es eine Möglichkeit, eine hellere Farbe zu erhalten, als wenn Blau 1 (Max) ist
CoreCode
@CoreCode nein, nicht wirklich. Es sei denn, Sie möchten die Birghtness des Gerätebildschirms ändern :) Siehe meine Antwort.
1

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.

Microbob
quelle
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
quelle
0

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

}
Zorayr
quelle
0

Ich rendere farbige Zellen basierend auf einem Statuswert:

Statusbilder

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.

Besi
quelle
0

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

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

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

Jiulong Zhao
quelle
Diese Methode ist nur für NSColor verfügbar, nicht für UIColor.
Followben