148

我希望能够将任何 UIColor 变成渐变。我打算这样做的方式是使用 Core Graphics 绘制渐变。我想要做的是获得一种颜色，让我们说：

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

并得到一个 UIColor ，它更暗一些，更亮一些。有谁知道如何做到这一点？谢谢你。

4

19 回答 19

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

像这样使用它：

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

编辑：正如@Anchu Chimala 指出的那样，为了获得最大的灵活性，这些方法应该作为 UIColor 类别来实现。此外，从@Riley 的想法来看，最好让颜色按比例变暗或变亮，而不是添加或减去常数值。正如@jrturton 指出的那样，没有必要操纵 RGB 组件。最好修改亮度属性本身。总而言之：

@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
于 2012-07-22T06:11:43.357 回答
59

TL;博士：

迅速：

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

用法：

let lightColor = somethingDark.lighterColor

目标-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 的评论中是正确的（接受的答案）- HSB（或 HSV）和 RGB 解决方案给出了完全不同的结果。RGB 只是添加（或使颜色更接近）白色，而 HSB 解决方案使颜色更接近亮度等级的边缘 - 基本上以黑色开始并以纯色结束......

基本上亮度（值）使颜色更接近或更接近黑色，而饱和度使其更接近或更接近白色......

如此处所示：

HSV 彩色图

因此，使颜色实际上更亮（即更接近白色......）的解决方案将是使其饱和度值更小，从而产生以下解决方案：

- (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;
}
于 2014-04-16T21:42:26.427 回答
41

适用于iOS 和 OS X的Swift通用扩展，使用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

    }

}

用法 ：

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)

或（使用默认值）：

color.lighter()
color.darker()

样本 ：

在此处输入图像描述

于 2015-07-16T23:58:03.943 回答
34

我只是想在 RGB 中给出相同的结果，而不是

  • 将带有 alpha x% 的颜色放在白色背景上以变亮
  • 将带有 alpha x% 的颜色放在黑色背景上以变暗

这给出了相同的结果，AFAIK，而不是在渐变大小的 x% 处选择渐变“颜色到白色”或“颜色到黑色”中的颜色。

为此，数学很简单：

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

以下是一些颜色的示例

示例更深和更亮

于 2016-03-11T21:20:27.153 回答
24

user529758 在 Swift 中的解决方案：

较深的颜色：

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

浅色：

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()
}
于 2014-12-09T19:53:24.307 回答
14

如果将 RGB 颜色转换为HSL 颜色模型，则可以将 L = 亮度分量从 L = 0.0（黑色）到 L = 0.5（自然色）更改为 L = 1.0（白色）。UIColor不能直接处理 HSL，但是有转换 RGB <-> HSL 的公式。

于 2012-07-22T06:39:16.593 回答
7

此线程中的所有其他答案都使用RGB 颜色系统或简单地更改HSB 系统的色调或亮度值。正如这篇精彩的博客文章中详细解释的那样，使颜色变浅或变深的正确方法是改变它的luminance值。其他答案都没有。如果您想正确地做，请使用我的解决方案或在阅读博客文章后编写您自己的解决方案。

不幸的是，在默认情况下更改 UIColor 的任何属性都非常麻烦。此外，Apple 甚至不支持任何基于 LAB 的色彩空间，如类中的 HCL （in LAB 是我们正在寻找的值）。UIColorLluminance

使用HandyUIKit（通过 Carthage 安装）增加了对HCL的支持，让您的生活更轻松：

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)

还有一个应用相对更改的选项（推荐）：

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

请注意，HandyUIKit 还在您的项目中添加了一些其他方便的 UI 功能——查看 GitHub 上的自述文件以获取更多详细信息。

我希望它有帮助！

免责声明：我是 HandyUIKit 的作者。

于 2016-06-30T18:32:17.380 回答
6

发布的解决方案都没有适用于所有颜色和阴影，但后来我偶然发现了这个库，它为 UIColor 提供了一组非常好的实现扩展。

具体来说，它具有作为其 HSL 实现的一部分的减轻功能：(UIColor *)lighten:(CGFloat)amount- 完美运行。

于 2014-11-19T23:47:44.457 回答
6

Sebyddd作为扩展的解决方案：

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

用法：

let darkerYellow = UIColor.yellow.darker()
let lighterYellow = UIColor.yellow.lighter()
于 2017-08-14T09:59:48.180 回答
3

如果您希望 user529758 的解决方案适用于灰色阴影（例如[UIColor lightGrayColor]，或者[UIColor darkGrayColor] 您必须像这样改进它：

- (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在灰色阴影上调用时失败（并返回false），因此您需要使用getWhite:alpha.

于 2014-05-14T23:36:47.417 回答
3

斯威夫特 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
     }
   }
}
于 2020-03-25T09:56:51.820 回答
2

UIColor 扩展和修复lighterColorForColor

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()
  }
}
于 2015-02-27T14:07:58.023 回答
1

我不确定您是否正在寻找某种 Objective-C 答案，但根据 RGBA 指定的颜色如何工作，我认为您可以根据任意因素简单地缩放 RGB 值以获得“更亮”或“更暗”的阴影。例如，您可能有蓝色：

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

想要深蓝色？将 RGB 值乘以 0.9：

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

瞧。或者也许你有一个橙子：

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

选择另一个比例因子，例如 0.8：

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

这就是你想要的那种效果吗？

于 2012-07-22T06:10:31.890 回答
1

使用适用于 iOS 12 的 Swift 4.x 在 Xcode 10 中测试

从作为 UIColor 的颜色开始，然后选择一个变暗因子（作为 CGFloat）

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

CGColor 类型有一个可选值components，它将颜色分解为 RGBA（作为值在 0 和 1 之间的 CGFloat 数组）。然后，您可以使用从 CGColor 获取的 RGBA 值重建 UIColor 并对其进行操作。

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

在此示例中，每个 RGB 值均除以 2，使颜色与以前一样暗一半。alpha 值保持不变，但您也可以在 alpha 值而不是 RGB 上应用变暗因子。

于 2018-12-04T15:44:02.313 回答
0

理想情况下，这些函数应该封装在一个UIColor名为 , 的扩展中UIColor+Brightness.swift，并具有可配置的亮度 - 请参见下面的示例：

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

}
于 2015-05-14T06:48:02.810 回答
0

我根据状态值渲染彩色单元格：

状态图像

为此，在使用 CryingHippo 的建议出现错误后，我基于一些旧的 objc 代码编写了一个快速扩展：

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

同样适用NSColor。只需替换UIColor为NSColor.

于 2016-01-29T18:39:28.093 回答
0

这是一个 UIColor 类别，它还允许控制颜色变化的量。

- (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;
}
于 2017-12-02T02:45:00.680 回答
0

基于 @Sebyddd 答案的 Swift 扩展：

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()
    }
}
于 2018-02-09T12:44:59.290 回答
-1

对于较深的颜色，这是最简单的： theColor = [theColor shadowWithLevel:s]; //s:0.0 到 1.0

于 2019-08-05T00:15:31.243 回答