webentwicklung-frage-antwort-db.com.de

Holen Sie sich etwas hellere und dunklere Farben von UIColor

Ich wollte jeden UIColor in einen Farbverlauf umwandeln. Ich beabsichtige, dies zu tun, indem Sie mit Core Graphics einen Farbverlauf zeichnen. Was ich versuche, ist eine Farbe zu bekommen, sagen wir:

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

und Sie erhalten eine UIColor, die ein paar Nuancen dunkler und ein paar Nuancen heller ist. Weiß jemand, wie das geht? Vielen Dank.

139
CoreCode
- (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: Wie @Anchu Chimala darauf hinweist, sollten diese Methoden für maximale Flexibilität als UIColor-Kategorie implementiert werden. Aus @ Rileys Idee kann es auch eine bessere Idee sein, die Farbe proportional dunkler oder heller zu gestalten, anstatt konstante Werte hinzuzufügen oder zu entfernen. Wie @jrturton hervorgehoben hat, müssen die RGB-Komponenten nicht manipuliert werden. 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
273
user529758

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

Verwendungszweck:

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

Grundsätzlich bewirkt die Helligkeit (Wert), dass die Farbe weniger oder mehr näher an Schwarz liegt, wohingegen die Sättigung weniger oder mehr nahe an Weiß liegt. 

Wie hier zu sehen:

HSV color graph

Die Lösung, um eine Farbe tatsächlich heller zu machen (d. H. Näher an Weiß ...), besteht darin, ihren Sättigungswert kleiner zu machen, was zu dieser 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;
}
51
Aviel Gross

Swift universelle 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

    }

}

Verwendungszweck : 

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

Probe : 

enter image description here

37
CryingHippo

user529758s Lösung 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()
}
23
Sebyddd

Ich wollte nur das gleiche Ergebnis in RGB als geben

  • 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 dunkler zu machen

Dies führt zu demselben Ergebnis, AFAIK, als das Auswählen der Farbe in einem Farbverlauf "Farbe zu Weiß" oder "Farbe zu Schwarz" bei x% der Farbverlaufsgröße.

Zu diesem Zweck ist die Mathematik einfach:

// UIColor+Mix.Swift
import UIKit
extension UIColor {

    func mixLighter (amount: CGFloat = 0.25) -> UIColor {
        return mixWithColor(UIColor.whiteColor(), amount:amount)
    }

    func mixDarker (amount: CGFloat = 0.25) -> UIColor {
        return mixWithColor(UIColor.blackColor(), amount:amount)
    }

    func mixWithColor(color: UIColor, amount: CGFloat = 0.25) -> UIColor {
        var r1     : CGFloat = 0
        var g1     : CGFloat = 0
        var b1     : CGFloat = 0
        var alpha1 : CGFloat = 0
        var r2     : CGFloat = 0
        var g2     : CGFloat = 0
        var b2     : CGFloat = 0
        var alpha2 : CGFloat = 0

        self.getRed (&r1, green: &g1, blue: &b1, alpha: &alpha1)
        color.getRed(&r2, green: &g2, blue: &b2, alpha: &alpha2)
        return UIColor( red:r1*(1.0-amount)+r2*amount,
                        green:g1*(1.0-amount)+g2*amount,
                        blue:b1*(1.0-amount)+b2*amount,
                        alpha: alpha1 )
    }
}

Hier sind Beispiele mit einigen Farben

 Examples Darker and Lighter

19
FredericP

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. UIColor kann HSL nicht direkt behandeln, es gibt jedoch eine Formel zum Konvertieren von RGB <-> HSL. 

13
Martin R

Keine der Lösungen gab recht für alle Farben und Schattierungen aus, aber dann bin ich auf diese Bibliothek gestoßen, das eine Reihe von sehr gut implementierten Erweiterungen für UIColor bereitstellt. 

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

6
Terminus

UIColor Verlängerung und FixierfeuerzeugColorForColor

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

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

Verwendungszweck:

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

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 Blogbeitrag ausführlich beschrieben, ist der korrekte-Weg, eine Farbe heller oder dunkler zu gestalten, ihren luminance-Wert zu ändern. Keine der anderen Antworten tut das. Wenn Sie es richtig machen möchten, verwenden Sie meine Lösung oder schreiben Sie Ihre eigene, nachdem Sie den Blogbeitrag gelesen haben.


Leider ist es ziemlich umständlich, eines der Attribute eines UIColor standardmäßig zu ändern. Apple unterstützt auch keinen LAB-basierten Farbraum wie HCL in der UIColor-Klasse (die L in LAB ist der von uns gesuchte luminance-Wert).

Die Verwendung von HandyUIKit (Installation über Carthage) fügt Unterstützung für HCL hinzu und macht Ihr Leben um einiges einfacher:

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 auch einige andere praktische UI-Funktionen zu Ihrem Projekt hinzufügt - checkout dessen README auf GitHub für weitere Details.

Ich hoffe, es hilft!

2
Dschee

Wenn die Lösung von user529758 mit Graustufen (wie [UIColor lightGrayColor] oder [UIColor darkGrayColor]) arbeiten soll, müssen Sie diese 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:alpha schlägt fehl (und gibt false zurück), wenn ein grauer Farbton aufgerufen wird. Daher müssen Sie getWhite:alpha verwenden. 

2

Ich bin mir nicht sicher, ob Sie nach einer Art Objective-C-Antwort suchen, aber basierend auf den von RGBA festgelegten Farben denke ich, dass Sie die RGB-Werte einfach nach einem beliebigen Faktor skalieren können, um ein "helleres" Ergebnis zu erzielen "dunkler" Schatten. Zum Beispiel könnten Sie eine blaue 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, zB 0,8:

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

Ist das die Art von Effekt, nach der Sie suchen?

1
ravron

Idealerweise sollten die Funktionen in einer UIColor-Erweiterung namens UIColor+Brightness.Swift eingeschlossen 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()
  }

}
0
Zorayr

Hier ist eine UIColor-Kategorie, die auch die Kontrolle über den Umfang der Farbänderung ermöglicht.

- (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
Blago

Eine schnelle 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()
    }
}
0
Balázs Vincze

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

0
Jiulong Zhao

In Xcode 10 mit Swift 4.x für iOS 12 getestet

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

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

Der Typ CGColor hat einen optionalen Wert components, der die Farbe in RGBA aufteilt (als CGFloat-Array mit Werten zwischen 0 und 1). Sie können dann eine UIColor mit Hilfe von RGBA-Werten aus 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 wurde wie zuvor. Der Alpha-Wert ist gleich geblieben, Sie können jedoch statt des RGB auch den Abdunklungsfaktor auf den Alpha-Wert anwenden. 

0
Microbob

Ich mache farbige Zellen basierend auf einem Statuswert:

status-images

Dafür habe ich eine Swift-Erweiterung geschrieben, die auf altem OBJC-Code basiert, nachdem ich einen Fehler mit dem Vorschlag von CryingHippo erhalten hatte:

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

Dasselbe funktioniert auch für NSColor. Ersetzen Sie einfach UIColor durch NSColor.

0
Besi