Ottieni un colore leggermente più chiaro e più scuro da UIColor


144

Stavo cercando di poter trasformare qualsiasi UIColor in una sfumatura. Il modo in cui intendo farlo è utilizzare Core Graphics per disegnare un gradiente. Quello che sto cercando di fare è ottenere un colore, diciamo:

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

e ottieni un UIColor che è di alcune tonalità più scure e alcune tonalità più chiare. Qualcuno sa come fare questo? Grazie.


1
"gradiente" implica che una porzione dell'immagine sarà una tonalità del colore mentre un'altra porzione sarà una tonalità più scura o più chiara. È questo un altro modo di definire ciò che vuoi fare?
Michael Dautermann,

2
Dai un'occhiata a questa libreria github.com/yannickl/DynamicColor
onmyway133

Swift utilizzando saturazione tonalità e leggerezza stackoverflow.com/a/30012117/2303865
Leo Dabus

Risposte:


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

Usalo in questo modo:

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

EDIT : come sottolineato da @Anchu Chimala, per la massima flessibilità, questi metodi dovrebbero essere implementati come categoria UIColor. Inoltre, dall'idea di @ Riley, potrebbe essere un'idea migliore rendere il colore opportunamente più scuro o più chiaro invece di aggiungere o sottrarre valori costanti. Come ha sottolineato @jrturton, non è necessario manipolare i componenti RGB; è meglio modificare la proprietà di luminosità stessa. Tutto sommato:

@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
Perché usare RGB quando puoi fare lo stesso con tonalità, saturazione, luminosità, quindi ricostruire il colore con la luminosità modificata?
jrturton,

2
Ho provato io stesso con la versione HSB e non ha funzionato come previsto. Nonostante la getHue:saturation:brightnessfirma di UIKit, sembra che funzioni con HSV anziché HSB. Cambiare la luminosità (quindi il valore) in questo contesto non funzionerà. Ad esempio il rosso puro (rgb (255,0,0)) avrà una luminosità / valore di 1, rendendo quindi impossibile l'illuminazione attraverso la luminosità. Ho finito invece per lavorare con le modifiche ai valori RGB.
rchampourlier,

2
Penso che ci sia qualcosa di confuso nella tua risposta: prendi i due approcci (uno con RGB e l'altro con HSB per la versione della categoria), che non hanno lo stesso risultato ... E questa potrebbe essere una questione di significato: lo schiarimento è davvero per me che rende il colore tendente al bianco (scurendo il nero), mentre cambiare la luminosità / valore lo rende più forte (resp. più chiaro).
rchampourlier,

4
Questo metodo fallirà se vengono utilizzati su tonalità di grigio. getHue:saturation:brightness:alpharestituirà FALSO.
Matthieu Riegler,

2
Mi chiedo perché questa sia la risposta accettata poiché entrambe le soluzioni suggerite sono errate . Entrambi cambiano semplicemente i valori teorici che hanno poco a che fare con ciò che gli esseri umani percepiscono come colori "più chiari" o "più scuri". Consiglio di leggere questo fantastico post (shortlink: goo.gl/qqgk9V) per capire cosa intendo. Spiega che il luminancevalore dello spazio colore LAB è quello vero di cui dovresti preoccuparti quando rendi i colori più chiari / scuri. Vedi la mia risposta su come utilizzarlo e risolvere questo problema nel modo giusto.
Jeehut,

59

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

Uso:

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 aveva ragione nel suo commento a @ user529758 (La risposta accettata) - Le soluzioni HSB (o HSV) e RGB danno risultati completamente diversi. RGB aggiunge semplicemente (o rende il colore più vicino al) bianco, e la soluzione HSB avvicina il colore al bordo nella scala Brigtness - che fondamentalmente inizia con il nero e termina con il colore puro ...

Fondamentalmente la luminosità (valore) rende il colore più o meno vicino al nero, dove la saturazione lo rende più o meno vicino al bianco ...

Come visto qui:

Grafico a colori HSV

Quindi la soluzione per rendere un colore più brillante realtà (cioè più vicino al bianco ...) sarà quello di rendere il suo valore di saturazione più piccoli , con conseguente questa soluzione:

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

Riguardo a come rendere i colori più chiari: ho ottenuto il miglior risultato riducendo la saturazione E aumentando la luminosità / valore. Questa risposta funziona alla grande per i colori "in cima" alla torta nell'immagine. Ma la maggior parte dei colori cadrà da qualche parte "dentro" la torta. Per avvicinarli al bianco è necessario spostarli anche "in alto" (valore crescente).
Pejalo,

Il valore crescente potrebbe sembrare funzionare, ma non sarà la funzionalità "core" di "ottenere un colore più chiaro".
Allo

38

Estensione universale Swift per iOS e OS X , usando 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

    }

}

Utilizzo:

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)

OPPURE (con i valori predefiniti):

color.lighter()
color.darker()

Campione :

inserisci qui la descrizione dell'immagine


Ho ricevuto un errore: -getHue: saturazione: luminosità: alfa: non valido per NSColor NSCalibratedWhiteColorSpace 0 1; è necessario prima convertire lo spazio colore.
Besi,

2
Risolvilo aggiungendo: let color = usingColorSpaceName(NSCalibratedRGBColorSpace) e quindi sostituendo la getHuechiamata con una chiamata a colore:color?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
Oskar

Manca la funzione _prima della quantità di parole. Dovrebbe essereprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {
Codemonk,

Suggerisco di aggiungere il suggerimento di @Oskar alla risposta. Ciò ha risolto un arresto anomalo del runtime per me.
Besi,

29

Volevo solo dare lo stesso risultato, in RGB, di

  • posizionando il colore con alpha x% su uno sfondo bianco per schiarire
  • posizionando il colore con alpha x% su uno sfondo nero per scurirlo

Il che dà lo stesso risultato, AFAIK, rispetto alla scelta del colore in una sfumatura "colore al bianco" o "colore al nero", al x% della dimensione del gradiente.

A tale scopo, la matematica è semplice:

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

Ecco alcuni esempi con alcuni colori

Esempi più scuri e più chiari


Penso che questa sia la migliore implementazione senza ricorrere a una libreria esterna che implementa lo spazio colore HSL
gog

24

La soluzione di user529758 in Swift:

Colore più scuro:

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

Colore più chiaro:

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
Questa è una buona risposta, tranne che sarebbe più conveniente se fosse dichiarata come estensione della classe UIColor semplicemente come var darker: UIColorad esempio.
Bruno Philipe,

13

Se si converte il colore RGB nel modello di colore HSL, è possibile variare la componente L = luminosità da L = 0,0 (nero) su L = 0,5 (colore naturale) a L = 1,0 (bianco). UIColornon è in grado di gestire direttamente HSL, ma esistono delle formule per convertire RGB <-> HSL.



8
La differenza tra il modello di colore HSL e HSB (talvolta chiamato anche HSV) è che in HSB L = 1.0 corrisponde al colore puro, mentre in HSL L = 1.0 corrisponde al bianco e L = 0,5 al colore puro. Dal momento che il poster originale ha richiesto, ad esempio, un modo per rendere più chiaro il colore blu (RGB = 0/0/1), penso che HSL sia più flessibile.
Martin R,

6

Nessuna delle soluzioni pubblicate ha funzionato abbastanza per tutti i colori e le sfumature, ma poi mi sono imbattuto in questa libreria che fornisce una serie di estensioni molto ben implementate a UIColor.

Nello specifico ha una funzione schiarente come parte della sua implementazione HSL: (UIColor *)lighten:(CGFloat)amount- che funziona perfettamente.


5

Sebyddd soluzione come estensione:

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

Uso:

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

2

Se vuoi che la soluzione di user529758 funzioni con sfumature di grigio (come [UIColor lightGrayColor]o [UIColor darkGrayColor] devi migliorarla in questo modo:

- (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:alphafallisce (e ritorna false) quando viene chiamato su una sfumatura grigia, quindi è necessario utilizzare getWhite:alpha.


2

Estensione UIColor e accendino di fissaggioColorForColor

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

Tutte le altre risposte in questo thread usano il sistema di colore RGB o semplicemente cambiano il valore di tonalità o luminosità del sistema HSB . Come spiegato in dettaglio in questo fantastico post sul blog, il modo corretto di rendere un colore più chiaro o più scuro è quello di cambiarne il luminancevalore. Nessuna delle altre risposte lo fa. Se vuoi farlo nel modo giusto, usa la mia soluzione o scrivine una tua dopo aver letto il post sul blog.


Sfortunatamente è piuttosto una seccatura cambiare qualsiasi attributo di un UIColor di default . Inoltre, Apple non supporta nemmeno uno spazio colore basato su LAB come HCL nella UIColorclasse ( Lin LAB è il luminancevalore che stiamo cercando).

L'uso di HandyUIKit (installalo tramite Cartagine) aggiunge il supporto per HCL e semplifica la vita :

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)

C'è anche un'opzione per applicare una modifica relativa (consigliata):

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

Nota che HandyUIKit aggiunge anche alcune altre utili funzionalità dell'interfaccia utente al tuo progetto: dai un'occhiata al suo README su GitHub per maggiori dettagli.

Spero possa essere d'aiuto!


Per la mia app traccio percorsi su mappe. Volevo tracciare il percorso con all'interno di un colore con una luminosità del 100% e il bordo con una variante più scura di quel colore. Poiché la linea interna aveva già una luminosità del 100%, nessuno dei metodi ha funzionato. Anche cambiare la luminanza come menzionato sopra non ha funzionato. Tuttavia, ridurre la luminosità usando questa estensione molto bella ha fatto il trucco per me. 'color.change (.brightness, by: -0.5)' Questa estensione è molto flessibile nel suo utilizzo e ha molte opzioni. Ti consiglio se, soprattutto se hai un'app con diversi temi o tavolozze di colori.
guido,

1

Non sono sicuro se stai cercando una sorta di risposta Objective-C, ma in base a come funzionano i colori specificati da RGBA, penso che puoi semplicemente ridimensionare i valori RGB in base a un fattore arbitrario per ottenere un "più leggero" o tonalità "più scura". Ad esempio, potresti avere un blu:

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

Vuoi un blu più scuro? Moltiplica i valori RGB per 0,9:

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

Ecco. O forse hai un'arancia:

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

Scegli un altro fattore di scala, diciamo 0.8:

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

È questo il tipo di effetto che stai cercando?


Ok Sì, questa è la metà di ciò di cui ho bisogno. C'è un modo per ottenere un colore più chiaro quando il blu è 1 (massimo)
CoreCode

@CoreCode no, non proprio. A meno che tu non voglia cambiare la luminosità dello schermo del dispositivo :) Vedi la mia risposta.

1

Testato in Xcode 10 con Swift 4.x per iOS 12

Inizia con il tuo colore come UIColor e scegli un fattore di oscuramento (come CGFloat)

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

Il tipo CGColor ha un valore opzionale componentsche suddivide il colore in RGBA (come un array CGFloat con valori compresi tra 0 e 1). È quindi possibile ricostruire un UIColor usando i valori RGBA presi da CGColor e manipolarli.

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

In questo esempio, ciascuno dei valori RGB è stato diviso per 2, rendendo il colore la metà più scuro di prima. Il valore alfa è rimasto lo stesso, ma in alternativa è possibile applicare il fattore di oscuramento sul valore alfa anziché su RGB.


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


     }
    }
}

0

Idealmente, le funzioni dovrebbero essere incapsulate all'interno di un UIColorinterno chiamato UIColor+Brightness.swift, e avere una luminosità configurabile - vedi esempio sotto:

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

Rendo celle colorate in base a un valore di stato:

status-immagini

Per questo ho scritto una rapida estensione basata su un vecchio codice objc dopo aver ricevuto un errore utilizzando il suggerimento di 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)
    }
}

Lo stesso vale anche per NSColor. Sostituisci semplicemente UIColorcon NSColor.


0

Ecco una categoria UIColor che consente anche il controllo della quantità di cambio colore.

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

Un'estensione Swift basata sulla risposta @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

per colori più scuri, questo è il più semplice: theColor = [theColor shadowWithLevel: s]; //s:0.0 a 1.0


Questo metodo è disponibile solo su NSColor, non UIColor.
followben
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.