Saya ingin dapat mengubah UIColor menjadi gradien. Cara saya bermaksud melakukan ini adalah dengan menggunakan Core Graphics untuk menggambar gradien. Apa yang saya coba lakukan adalah mendapatkan warna, katakan saja:

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

dan dapatkan UIColor yang beberapa warna lebih gelap dan beberapa warna lebih terang. Adakah yang tahu bagaimana melakukan ini? Terima kasih.

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

Gunakan seperti ini:

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

EDIT : seperti yang ditunjukkan oleh @Anchu Chimala, untuk fleksibilitas maksimum, metode ini harus diimplementasikan sebagai kategori UIColor. Juga, dari ide @ Riley, mungkin ide yang lebih baik untuk membuat warna lebih gelap atau lebih terang daripada menambahkan atau mengurangi nilai konstan. Seperti yang ditunjukkan oleh @jrturton, tidak perlu memanipulasi komponen RGB; lebih baik untuk memodifikasi properti kecerahan itu sendiri. Semua seutuhnya:

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

Cepat:

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

Pemakaian:

let lightColor = somethingDark.lighterColor

Tujuan-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 benar dalam komentarnya ke @ user529758 (Jawaban yang diterima) - Solusi HSB (Atau HSV) dan RGB memberikan hasil yang sangat berbeda. RGB hanya menambahkan (Atau membuat warna lebih dekat dengan) putih, dan solusi HSB membawa warna lebih dekat ke tepi dalam skala Brigtness - yang pada dasarnya dimulai dengan warna hitam dan berakhir dengan warna murni ...

Pada dasarnya Kecerahan (Nilai) membuat warna kurang atau lebih dekat ke hitam, di mana Saturasi membuatnya kurang atau lebih dekat ...

Seperti yang terlihat di sini:

Jadi solusi untuk membuat warna benar-benar lebih terang (yaitu lebih dekat ke putih ...) akan membuat nilai Saturasi itu lebih kecil , menghasilkan solusi ini:

- (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 ekstensi universal untuk iOS dan OS X , menggunakan 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

    }

}

Penggunaan:

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)

ATAU (dengan nilai default):

color.lighter()
color.darker()

Sampel :

Saya hanya ingin memberikan hasil yang sama, di RGB, daripada

• menempatkan warna dengan alpha x% di atas latar belakang putih untuk meringankan
• menempatkan warna dengan alpha x% di atas latar belakang hitam untuk menggelapkan

Yang memberikan hasil yang sama, AFAIK, daripada memilih warna dalam gradien 'warna menjadi putih' atau 'warna menjadi hitam', pada x% dari ukuran gradien.

Untuk tujuan itu, matematika sederhana:

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

Berikut adalah contoh dengan beberapa warna

solusi user529758 di Swift:

Warna lebih gelap:

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

Warna yang lebih terang:

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

Jika Anda mengubah warna RGB ke model warna HSL maka Anda dapat memvariasikan L = komponen terang dari L = 0,0 (hitam) di atas L = 0,5 (warna alami) ke L = 1,0 (putih). UIColortidak dapat menangani HSL secara langsung, tetapi ada rumus untuk mengonversi RGB <-> HSL.

Tak satu pun dari solusi yang diposting cukup berhasil untuk semua warna dan nuansa, tapi kemudian saya menemukan perpustakaan ini yang menyediakan serangkaian ekstensi yang diimplementasikan dengan sangat baik ke UIColor.

Secara khusus ia memiliki fungsi meringankan sebagai bagian dari implementasi HSL: (UIColor *)lighten:(CGFloat)amount- yang bekerja dengan sempurna.

Sebyddd solusi sebagai ekstensi:

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

Pemakaian:

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

Jika Anda ingin solusi user529758 bekerja dengan nuansa abu-abu (seperti [UIColor lightGrayColor]atau [UIColor darkGrayColor] Anda harus memperbaikinya seperti itu:

- (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:alphagagal (dan kembali false) ketika dipanggil dengan warna abu-abu karena itu Anda harus menggunakangetWhite:alpha .

Ekstensi UIColor dan memperbaiki korek apiColorForColor

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

Semua jawaban lain di utas ini menggunakan sistem warna RGB atau hanya mengubah nilai rona atau kecerahan sistem HSB . Seperti dijelaskan secara rinci dalam posting blog yang hebat ini , cara yang benar untuk membuat warna lebih terang atau lebih gelap adalah dengan mengubah luminancenilainya. Tidak ada jawaban lain yang melakukannya. Jika Anda ingin melakukannya dengan benar, maka gunakan solusi saya atau tulis sendiri setelah membaca posting blog.

Sayangnya itu cukup merepotkan untuk mengubah atribut UIColor secara default . Juga Apple bahkan tidak mendukung ruang warna berbasis LAB seperti HCL di UIColorkelas ( LLAB di adalah luminancenilai yang kita cari).

Menggunakan HandyUIKit (instal melalui Carthage) menambah dukungan untuk HCL dan membuat hidup Anda jauh lebih mudah :

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)

Ada juga opsi untuk menerapkan perubahan relatif (disarankan):

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

Perhatikan bahwa HandyUIKit juga menambahkan beberapa fitur UI berguna lainnya ke proyek Anda - checkout README -nya di GitHub untuk detail lebih lanjut.

Saya harap ini membantu!

Saya tidak yakin apakah Anda sedang mencari semacam jawaban Objective-C, tetapi berdasarkan bagaimana warna yang ditentukan oleh RGBA bekerja, saya pikir Anda bisa skala nilai-nilai RGB sesuai dengan faktor arbitrer untuk mendapatkan "lebih ringan" atau naungan "gelap". Misalnya, Anda mungkin memiliki warna biru:

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

Ingin yang lebih gelap? Lipat gandakan nilai RGB dengan 0,9:

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

Voila. Atau mungkin Anda memiliki jeruk:

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

Pilih faktor skala lain, katakanlah, 0,8:

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

Apakah itu jenis efek yang Anda cari?

Diuji dalam Xcode 10 dengan Swift 4.x untuk iOS 12

Mulai dengan warna Anda sebagai UIColor dan pilih faktor penggelapan (sebagai CGFloat)

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

Tipe CGColor memiliki nilai opsional componentsyang memecah warna menjadi RGBA (sebagai array CGFloat dengan nilai antara 0 dan 1). Anda kemudian dapat merekonstruksi UIColor menggunakan nilai-nilai RGBA yang diambil dari CGColor dan memanipulasinya.

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

Dalam contoh ini, masing-masing RGB valuse dibagi 2, membuat warna setengah gelap seperti sebelumnya. Nilai alfa tetap sama, tetapi Anda bisa menerapkan faktor gelap pada nilai alfa daripada RGB.

Cepat 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


     }
    }
}

Idealnya, fungsi-fungsi tersebut harus dienkapsulasi di dalam UIColorekstensi yang disebut UIColor+Brightness.swift,, dan memiliki kecerahan yang dapat dikonfigurasi - lihat contoh di bawah ini:

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

}

Saya membuat sel berwarna berdasarkan nilai status:

Untuk ini saya menulis ekstensi cepat berdasarkan pada beberapa kode objc lama setelah saya mendapat kesalahan menggunakan saran 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)
    }
}

Hal yang sama NSColorjuga berlaku. Cukup ganti UIColordengan NSColor.

Berikut adalah kategori UIColor yang juga memungkinkan kontrol atas jumlah perubahan warna.

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

Ekstensi Swift berdasarkan jawaban @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()
    }
}

untuk warna yang lebih gelap, ini adalah yang paling sederhana: theColor = [theColor shadowWithLevel: s]; //s 8.00.0 hingga 1.0