Tôi đang tìm cách để có thể biến bất kỳ UIColor nào thành một gradient. Cách tôi dự định làm điều này là bằng cách sử dụng Core Graphics để vẽ một gradient. Những gì tôi đang cố gắng làm là để có được một màu sắc, hãy nói:

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

và nhận được một UIColor có một vài màu tối hơn và một vài màu sáng hơn. Có ai biết cách để làm điều này không? Cảm ơn bạn.

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

Sử dụng nó như thế này:

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

EDIT : như @Anchu Chimala đã chỉ ra, để linh hoạt tối đa, các phương pháp này nên được triển khai như một thể loại UIColor. Ngoài ra, từ ý tưởng của @ Riley, có thể là một ý tưởng tốt hơn để làm cho màu sắc tối hơn hoặc sáng hơn thay vì thêm hoặc bớt các giá trị không đổi. Như @jrturton đã chỉ ra, không cần thiết phải thao tác các thành phần RGB; tốt hơn là sửa đổi thuộc tính độ sáng của chính nó. Tất cả trong tất cả:

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

Nhanh:

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

Sử dụng:

let lightColor = somethingDark.lighterColor

Mục tiêu-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];
}

@rchampour trước đó đã đúng trong nhận xét của mình với @ user529758 (Câu trả lời được chấp nhận) - Các giải pháp HSB (Hoặc HSV) và RGB cho kết quả hoàn toàn khác nhau. RGB chỉ thêm (Hoặc làm cho màu gần hơn) màu trắng và giải pháp HSB mang màu sắc gần với cạnh hơn theo thang Brigtness - về cơ bản bắt đầu bằng màu đen và kết thúc bằng màu thuần ...

Về cơ bản Độ sáng (Giá trị) làm cho màu ít hoặc gần với màu đen hơn, trong đó Saturation làm cho nó ít hoặc gần với màu trắng hơn ...

Như đã thấy ở đây:

Vì vậy, giải pháp để làm cho màu thực sự sáng hơn (nghĩa là gần với màu trắng hơn ...) sẽ làm cho giá trị Độ bão hòa của nó nhỏ hơn , dẫn đến giải pháp này:

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

Tiện ích mở rộng phổ quát Swift cho iOS và OS X , sử dụng 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

    }

}

Sử dụng :

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)

HOẶC (với các giá trị mặc định):

color.lighter()
color.darker()

Mẫu vật :

Tôi chỉ muốn cho kết quả tương tự, trong RGB, hơn

• đặt màu với alpha x% trên nền trắng để làm sáng
• đặt màu với alpha x% trên nền đen để làm tối

Điều này cho kết quả tương tự, AFAIK, hơn là chọn màu theo độ dốc 'màu thành màu trắng' hoặc 'màu thành màu đen', với x% kích thước độ dốc.

Với mục đích đó, toán học rất đơn giản:

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

Dưới đây là ví dụ với một số màu sắc

giải pháp của user529758 trong Swift:

Màu tối hơn:

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

Màu nhạt hơn:

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

Nếu bạn chuyển đổi màu RGB thành mô hình màu HSL thì bạn có thể thay đổi thành phần L = lightness từ L = 0,0 (đen) thay vì L = 0,5 (màu tự nhiên) thành L = 1.0 (trắng). UIColorkhông thể xử lý trực tiếp HSL, nhưng có công thức để chuyển đổi RGB <-> HSL.

Không có giải pháp nào được đăng khá hiệu quả cho tất cả các màu và sắc thái, nhưng sau đó tôi tình cờ thấy thư viện này này cung cấp một bộ các phần mở rộng được triển khai rất tốt cho UIColor.

Cụ thể, nó có chức năng làm sáng như là một phần của việc thực hiện HSL: (UIColor *)lighten:(CGFloat)amount- hoạt động hoàn hảo.

Sebyddd giải pháp như một phần mở rộng:

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

Sử dụng:

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

Nếu bạn muốn giải pháp của user529758 hoạt động với các màu xám (như [UIColor lightGrayColor]hoặc [UIColor darkGrayColor] bạn phải cải thiện nó như thế:

- (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:alphathất bại (và trả về false) khi được gọi trên một bóng màu xám do đó bạn sẽ cần sử dụng getWhite:alpha.

Mở rộng UIColor và sửa lỗi bật lửaColorForColor

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

Tất cả các câu trả lời khác trong chuỗi này sử dụng hệ thống màu RGB hoặc đơn giản là thay đổi màu sắc hoặc giá trị độ sáng của hệ thống HSB . Như đã giải thích chi tiết trong blog tuyệt vời này gửi các đúng cách để làm cho một màu sáng hơn hoặc tối hơn là thay đổi của nó luminancegiá trị. Không có câu trả lời nào khác làm điều đó. Nếu bạn muốn làm đúng, hãy sử dụng giải pháp của tôi hoặc tự viết sau khi đọc bài đăng trên blog.

Thật không may, thật khó để thay đổi bất kỳ thuộc tính nào của UIColor theo mặc định . Ngoài ra, Apple thậm chí không hỗ trợ bất kỳ không gian màu nào dựa trên LAB như HCL trong UIColorlớp ( Ltrong LAB là luminancegiá trị chúng tôi đang tìm kiếm).

Sử dụng HandyUIKit (cài đặt nó qua Carthage) thêm hỗ trợ cho HCL và giúp cuộc sống của bạn dễ dàng hơn rất nhiều :

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)

Ngoài ra còn có một tùy chọn để áp dụng thay đổi tương đối (được khuyến nghị):

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

Lưu ý rằng HandyUIKit cũng thêm một số tính năng UI tiện dụng khác vào dự án của bạn - kiểm tra README của nó trên GitHub để biết thêm chi tiết.

Tôi hy vọng nó sẽ giúp!

Tôi không chắc liệu bạn có đang tìm kiếm một loại câu trả lời Objective-C nào không, nhưng dựa trên cách các màu được chỉ định bởi RGBA hoạt động, tôi nghĩ rằng bạn có thể đơn giản chia tỷ lệ các giá trị RGB theo một yếu tố tùy ý để có được "nhẹ hơn" hoặc Bóng tối "tối hơn". Ví dụ: bạn có thể có màu xanh:

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

Bạn muốn một màu xanh đậm hơn? Nhân các giá trị RGB với 0,9:

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

Voila. Hoặc có thể bạn có một quả cam:

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

Chọn một yếu tố tỷ lệ khác, giả sử, 0,8:

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

Đó có phải là loại hiệu ứng bạn đang tìm kiếm?

Đã thử nghiệm trong Xcode 10 với Swift 4.x cho iOS 12

Bắt đầu với màu của bạn là UIColor và chọn một yếu tố làm tối (dưới dạng CGFloat)

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

Loại CGColor có một giá trị tùy chọn componentsphá vỡ màu thành RGBA (dưới dạng mảng CGFloat với các giá trị nằm trong khoảng từ 0 đến 1). Sau đó, bạn có thể xây dựng lại một UIColor bằng các giá trị RGBA được lấy từ CGColor và thao tác với chúng.

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

Trong ví dụ này, mỗi valuse RGB được chia cho 2, làm cho màu sắc tối hơn một nửa so với trước đây. Giá trị alpha vẫn giữ nguyên, nhưng bạn có thể áp dụng thay thế hệ số làm tối trên giá trị alpha thay vì RGB.

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


     }
    }
}

Lý tưởng nhất là các chức năng nên được gói gọn trong một UIColortiện ích mở rộng được gọi UIColor+Brightness.swiftvà có độ sáng có thể định cấu hình - xem ví dụ bên dưới:

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

}

Tôi kết xuất các ô màu dựa trên giá trị trạng thái:

Vì điều này, tôi đã viết một phần mở rộng nhanh chóng dựa trên một số mã objc cũ sau khi tôi gặp lỗi khi sử dụng đề xuất của 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)
    }
}

Các công việc tương tự NSColorlà tốt. Đơn giản chỉ cần thay thế UIColorbằng NSColor.

Dưới đây là danh mục UIColor cũng cho phép kiểm soát lượng thay đổi màu.

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

Tiện ích mở rộng Swift dựa trên câu trả lời @Sitherddd:

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

Đối với màu tối hơn, đây là cách đơn giản nhất: theColor = [theColor ShadowWithLevel: s]; // s 0.0 đến 1.0