Herhangi bir UIColor'u bir gradyana dönüştürebilmek istiyordum. Bunu yapmayı amaçladığım yol, bir gradyan çizmek için Core Graphics kullanmaktır. Yapmaya çalıştığım şey bir renk elde etmek, diyelim ki:

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

ve birkaç ton daha koyu ve birkaç ton daha açık olan bir UIColor elde edin. Bunun nasıl yapılacağını bilen var mı? Teşekkür ederim.

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

Bunu şu şekilde kullanın:

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

DÜZENLE : @Anchu Chimala'nın belirttiği gibi, maksimum esneklik için bu yöntemler bir UIColor kategorisi olarak uygulanmalıdır. Ayrıca @ Riley'nin fikrine göre, sabit değerler eklemek veya çıkarmak yerine rengi proprtionel olarak daha koyu veya daha açık yapmak daha iyi bir fikir olabilir. @Jrturton'un belirttiği gibi, RGB bileşenlerini manipüle etmek gerekli değildir; parlaklık özelliğinin kendisini değiştirmek daha iyidir. Neticede:

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

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

Kullanım:

let lightColor = somethingDark.lighterColor

Amaç-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, @ user529758'e yaptığı yorumda haklıydı (Kabul edilen cevap) - HSB (Veya HSV) ve RGB çözümleri tamamen farklı sonuçlar veriyor. RGB sadece beyaz ekler (veya rengi yakınlaştırır) ve HSB çözümü rengi Brigtness ölçeğinde kenara yaklaştırır - temelde siyahla başlar ve saf renkle biter ...

Temelde Parlaklık (Değer) rengi siyaha daha az veya daha çok yaklaştırır, Doygunluk onu beyaza daha az veya daha çok yaklaştırır ...

Burada görüldüğü gibi:

Dolayısıyla, bir rengi gerçekten daha parlak hale getirmenin (yani beyaza daha yakın ...) çözümü, Doygunluk değerini küçültmek ve bu çözümle sonuçlanmak olacaktır:

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

GetHue kullanarak iOS ve OS X için Swift evrensel uzantı :

#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

    }

}

Kullanım:

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)

VEYA (varsayılan değerlerle):

color.lighter()
color.darker()

Örneklem :

Sadece RGB'de de aynı sonucu vermek istedim.

• rengi alfa x% ile beyaz bir arka plan üzerine yerleştirmek
• koyulaştırmak için rengi siyah bir arka plan üzerine alfa x% ile yerleştirmek

Bu, degrade boyutunun% x'inde, 'renkten beyaza' veya 'renkten siyaha' degradedeki rengi seçmekle aynı sonucu, AFAIK verir.

Bu amaçla matematik basittir:

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

İşte bazı renklerle örnekler

user529758'in Swift'deki çözümü:

Daha koyu renk:

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

Daha açık renk:

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

RGB rengini HSL renk modeline dönüştürürseniz, L = açıklık bileşenini L = 0,0 (siyah) ve L = 0,5 (doğal renk) ile L = 1,0 (beyaz) arasında değiştirebilirsiniz. UIColorHSL'yi doğrudan işleyemez, ancak RGB <-> HSL'yi dönüştürmek için bir formül vardır.

Gönderilen çözümlerin hiçbiri tüm renkler ve gölgeler için pek işe yaramadı, ancak sonra bu kitaplığa rastladım UIColor'a çok iyi uygulanmış bir dizi uzantı sağlayan rastladım.

Özellikle HSL uygulamasının bir parçası olarak hafifletme işlevi vardır: (UIColor *)lighten:(CGFloat)amount- mükemmel şekilde çalışır.

Sebyddd bir uzantı olarak çözüm:

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

Kullanım:

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

User529758'in çözümünün gri gölgelerle çalışmasını istiyorsanız (gibi [UIColor lightGrayColor]veya [UIColor darkGrayColor]bunu şu şekilde geliştirmelisiniz:

- (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:alphafalsegri bir gölgede çağrıldığında başarısız olur (ve geri döner ), bu nedenle kullanmanız gerekir getWhite:alpha.

UIColor uzatma ve lighterColorForColor sabitleme

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

Bu ileti dizisindeki diğer tüm yanıtlar ya RGB renk sistemini kullanır ya da HSB sisteminin tonunu veya parlaklık değerini değiştirir . Ayrıntılı olarak açıklandığı üzere bu büyük blogda yayınlamak doğru bir renk daha açık veya daha koyu onun değiştirmektir yapma yolu luminancedeğerini. Diğer cevapların hiçbiri bunu yapmıyor. Doğru yapmak istiyorsanız, o zaman benim çözümümü kullanın veya blog gönderisini okuduktan sonra kendi çözümünüzü yazın .

Ne yazık ki , bir UIColor'un herhangi bir özelliğini varsayılan olarak değiştirmek oldukça güçtür . Ayrıca Apple, sınıfta HCL gibi herhangi bir LAB tabanlı renk alanını desteklemiyor bile ( LAB'de aradığımız değer).UIColorLluminance

HandyUIKit kullanmak (Carthage aracılığıyla kurun), HCL için destek ekler ve hayatınızı çok daha kolay hale getirir :

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)

Ayrıca göreceli bir değişiklik uygulama seçeneği de vardır (önerilir):

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

HandyUIKit'in projenize başka kullanışlı UI özellikleri de eklediğini unutmayın - daha fazla ayrıntı için GitHub'daki README'ye bakın.

Umut ediyorum bu yardım eder!

Feragatname: HandyUIKit'in yazarıyım.

Bir çeşit Objective-C cevabı mı arıyorsunuz emin değilim, ancak RGBA tarafından belirlenen renklerin nasıl çalıştığına bağlı olarak, RGB değerlerini rastgele bir faktöre göre ölçeklendirerek "daha açık" veya "daha koyu" gölge. Örneğin, mavi olabilir:

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

Daha koyu bir mavi ister misiniz? RGB değerlerini 0,9 ile çarpın:

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

Voila. Ya da belki bir portakalınız var:

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

Başka bir ölçek faktörü seçin, örneğin 0.8:

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

Aradığınız türden bir etki bu mu?

İOS 12 için Swift 4.x ile Xcode 10'da test edildi

Bir UIColor olarak renginizle başlayın ve bir koyulaştırma faktörü seçin (bir CGFloat olarak)

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

CGColor türü components, rengi RGBA'ya ayıran isteğe bağlı bir değere sahiptir (0 ile 1 arasında değerlere sahip bir CGFloat dizisi olarak). Daha sonra, CGColor'dan alınan RGBA değerlerini kullanarak bir UIColor'u yeniden yapılandırabilir ve bunları değiştirebilirsiniz.

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

Bu örnekte, RGB değerlerinin her biri 2'ye bölünerek rengi eskisi kadar koyu hale getirdi. Alfa değeri aynı kaldı, ancak alternatif olarak koyulaştırma faktörünü RGB yerine alfa değerine uygulayabilirsiniz.

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


     }
    }
}

İdeal olarak, işlevler UIColoradı verilen bir uzantı içinde kapsüllenmeli UIColor+Brightness.swiftve yapılandırılabilir bir parlaklığa sahip olmalıdır - aşağıdaki örneğe bakın:

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

}

Renkli hücreleri bir durum değerine göre oluşturuyorum:

Bunun için CryingHippo'nun önerisini kullanırken bir hata aldıktan sonra bazı eski objc kodlarına dayalı hızlı bir uzantı yazdım:

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

Aynı şey için NSColorde geçerli. Basitçe yerine UIColorsahip NSColor.

İşte renk değişikliği miktarı üzerinde kontrol sağlayan bir UIColor kategorisi.

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

@Sebyddd yanıtına dayalı bir Swift uzantısı:

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

daha koyu renkler için bu en basitidir: theColor = [theColor shadowWithLevel: s]; //s:0.0 - 1.0