Отримайте трохи світліший і темніший колір від UIColor


144

Я шукав можливість перетворити будь-який UIColor на градієнт. Я маю намір це зробити, використовуючи Core Graphics, щоб намалювати градієнт. Що я намагаюся зробити, це отримати колір, скажімо:

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

і отримайте UIColor, який на кілька відтінків темніший і на кілька відтінків світліший. Хтось знає, як це зробити? Дякую.


1
"градієнт" означає, що одна частина вашого зображення буде одного відтінку кольору, а інша - більш темного або світлого відтінку. Це ще один спосіб визначення того, що ви хочете зробити?
Майкл Даутерманн

2
Погляньте на цю бібліотеку github.com/yannickl/DynamicColor
onmyway133

Swift з використанням колірного тону і насиченості світлини stackoverflow.com/a/30012117/2303865
Лео Dabus

Відповіді:


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

Використовуйте його так:

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

EDIT : як зазначав @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

2
Навіщо використовувати RGB, коли ви можете зробити те ж саме з відтінком, насиченістю, яскравістю, а потім просто перебудувати колір зі зміненою яскравістю?
jrturton

2
Я сам намагався з версією HSB, і це не спрацювало так, як очікувалося. Незважаючи на getHue:saturation:brightnessпідпис UIKit, схоже, він працює з HSV замість HSB. Зміна яскравості (так насправді значення) у цьому контексті не вийде. Наприклад, чистий червоний (rgb (255,0,0)) матиме яскравість / значення 1, завдяки чому освітлення через яскравість неможливе. Я замість цього працював зі змінами значень RGB.
rchampourlier

2
Я думаю, що у вашій відповіді є щось заплутане: ви використовуєте два підходи (один з RGB, а другий з HSB для версії категорії), які не мають однакового результату ... І це може бути питання про значення: освітлення дійсно для мене робить колір схильним до білого (темніший до чорного), а зміна яскравості / значення робить його сильнішим (відповідно світлішим).
rchampourlier

4
Цей спосіб вийде з ладу, якщо їх використовувати на сірих відтінках. getHue:saturation:brightness:alphaповерне ЛЮЖЕ.
Матьє Ріглер

2
Цікаво, чому це прийнята відповідь, оскільки обидва запропоновані рішення є невірними . Вони обидва лише змінюють теоретичні значення , які мало стосуються того, що люди сприймають як "світліші" або "темніші" кольори. Я рекомендую прочитати цей чудовий пост (коротке посилання: goo.gl/qqgk9V), щоб зрозуміти, що я маю на увазі. Це пояснює, що luminanceзначення кольорового простору LAB - це справжнє, про яке вам слід подбати, роблячи кольори світлішими / темнішими. Дивіться мою відповідь про те, як ви можете скористатися нею та вирішити цю проблему правильним шляхом.
Jeehut

59

TL; DR:

Швидкий:

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 наближає колір до краю за шкалою Brigtness - яка в основному починається з чорного і закінчується чистим кольором ...

В основному яскравість (значення) робить колір менш чи більше ближчим до чорного, де насиченість робить його менш чи більше ближчим до білого ...

Як видно тут:

Кольоровий графік 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;
}

Щодо покращення кольорів світлішими: я отримав найкращий результат за рахунок зменшення насиченості та збільшення яскравості / значення. Ця відповідь чудово підходить для кольорів «зверху» пирога на зображенні. Але більшість кольорів збираються десь «всередині» пирога. Наближення їх до білого вимагає і переміщення їх «вгору» (збільшення значення).
pejalo

Зростання значення може здатися спрацьовим, але це не буде "основним" функціоналом "отримати більш світлий колір". Таким же чином, щоб отримати більш темний колір, правильним підходом було б лише зменшити "Значення" і залишити Насичення таким, яким воно є ...
Авіель Гросс

38

Швидке універсальне розширення для iOS та OS X , використовуючи 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()

Зразок:

введіть тут опис зображення


Я отримав помилку: -getHue: насичення: яскравість: альфа: не вірно для NSColor NSCalibratedWhiteColorSpace 0 1; спочатку потрібно перетворити кольоровий простір.
Бесі

2
Виправте це, додавши:, let color = usingColorSpaceName(NSCalibratedRGBColorSpace) а потім замінивши getHueдзвінок кольором:color?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
Оскар

У функції відсутня а _перед сумою слова. Має бутиprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {
Codemonk

Я пропоную додати пропозицію @Oskar до відповіді. Це дозволило виправити аварійний процес для мене.
Бесі

29

Я просто хотів дати такий же результат, як у RGB, ніж

  • розміщення кольору з альфа х% над білим тлом, щоб полегшити
  • розміщення кольору з альфа х% над чорним фоном для затемнення

Що дає такий же результат, AFAIK, ніж підбір кольору в градієнті "колір до білого" або "колір до чорного", при х% від розміру градієнта.

З цією метою математика проста:

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

Ось приклади з деякими кольорами

Приклади темніші та світліші


Я думаю, що це найкраща реалізація, не вдаючись до зовнішньої бібліотеки, яка реалізує кольоровий простір HSL
gog

24

рішення користувача529758 у 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()
}

1
Це хороша відповідь, за винятком того, що було б зручніше, якби це було оголошено як розширення до класу UIColor просто як var darker: UIColorнаприклад.
Бруно Філіпе

13

Якщо ви перетворите колір RGB в кольорову модель HSL, ви можете змінити компонент L = легкість від L = 0,0 (чорний) над L = 0,5 (натуральний колір) до L = 1,0 (білий). UIColorне може працювати з HSL безпосередньо, але є формула для перетворення RGB <-> HSL.



8
Різниця між кольоровою моделлю HSL та HSB (іноді її також називають HSV) полягає в тому, що в HSB L = 1,0 відповідає чистому кольорові, тоді як у HSL L = 1,0 відповідає білому, а L = 0,5 - чистому кольорові. Оскільки оригінальний плакат запитував, наприклад, спосіб зробити колір синього (RGB = 0/0/1) світлішим, я думаю, що HSL є більш гнучким.
Мартін Р

6

Жодне з розміщених рішень не працювало для всіх кольорів і відтінків, але потім я натрапив на цю бібліотеку яка надає набір дуже добре реалізованих розширень для UIColor.

Зокрема, він має полегшену функцію в рамках впровадження HSL: (UIColor *)lighten:(CGFloat)amount- що працює ідеально.


5

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

2

Якщо ви хочете, щоб рішення користувача529758 працювало з сірими відтінками (наприклад, [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.


2

Розширення та фіксація UIColor легшеColorForColor

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

Усі інші відповіді в цій темі використовують або кольорову систему RGB, або просто змінюють значення відтінку або яскравості системи HSB . Як було детально роз'яснено в цьому великому блозі опублікувати на правильний спосіб зробити колір світліше або темніше , щоб змінити його luminanceзначення. Жоден з інших відповідей цього не робить. Якщо ви хочете зробити це правильно, скористайтеся моїм рішенням або напишіть своє, прочитавши допис у блозі.


На жаль , це досить клопоти , щоб змінити будь-якого з атрибутів UIColor за замовчуванням . Крім того, Apple навіть не підтримує будь-якого кольорового простору на основі LAB, як HCL у UIColorкласі (значення LLAB - це luminanceзначення, яке ми шукаємо).

Використання HandyUIKit (встановити його з допомогою Карфагена) додає підтримку 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 також додає у ваш проект деякі інші зручні функції інтерфейсу - перегляньте його README на GitHub для отримання більш детальної інформації.

Я сподіваюся, що це допомагає!


Для свого додатка я малюю маршрути на картах. Я хотів намалювати маршрут із внутрішньою лінією кольору зі 100% яскравістю та межею з більш темним варіантом цього кольору. Оскільки внутрішня лінія вже мала 100% яскравість, жоден із методів не працював. Також зміна освітленості, як згадувалося вище, не зробило хитрощів. Однак зменшення яскравості за допомогою цього дуже приємного розширення зробило для мене трюк. 'color.change (. яскравість, від: -0.5)' Це розширення є дуже гнучким у використанні та має багато варіантів. Рекомендую, якщо, особливо, якщо у вас є додаток з кількома темами або кольоровою палітрою.
Гвідо

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

Це такий ефект, який ви шукаєте?


Добре Так, це половина того, що мені потрібно. Чи є спосіб отримати більш світлий колір тоді, коли синій дорівнює 1 (Макс)
CoreCode

@CoreCode ні, не дуже. Якщо ви не хочете змінити швидкість екрана пристрою :) Дивіться мою відповідь.

1

Тестовано в Xcode 10 за допомогою Swift 4.x для iOS 12

Почніть зі свого кольору як UIColor і виберіть коефіцієнт потемніння (як CGFloat)

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

Тип CGColor має необов'язкове значення, componentsяке розбиває колір на RGBA (як масив CGFloat зі значеннями від 0 до 1). Потім можна реконструювати UIColor за допомогою значень RGBA, узятих із CGColor, і маніпулювати ними.

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, зробивши колір наполовину темнішим, як це було раніше. Значення альфа залишається колишнім, але ви можете застосувати коефіцієнт затемнення до значення альфа, а не RGB.


1

Швидкий 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

В ідеалі функції повинні бути капсульовані всередині 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()
  }

}

0

Я надаю кольорові комірки на основі значення стану:

статус-образи

Для цього я написав швидке розширення на основі старого коду objc після того, як я отримав помилку за допомогою пропозиції 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)
    }
}

Те саме працює і для NSColor. Просто замініть UIColorна NSColor.


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

0

Розширення Swift на основі відповіді @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

для більш темного кольору це найпростіший: theColor = [theColor shadowWithLevel: s]; //sgrees.0 до 1.0


Цей метод доступний лише на NSColor, а не на UIColor.
followben
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.