UIColor से थोड़ा हल्का और गहरा रंग प्राप्त करें

Question

मैं किसी भी UIColor को एक ढाल में बदलने में सक्षम होना चाह रहा था। जिस तरह से मैं ऐसा करने का इरादा कर रहा हूं वह एक ढाल बनाने के लिए कोर ग्राफिक्स का उपयोग करके है। मैं एक रंग पाने के लिए क्या करने की कोशिश कर रहा हूं, जो कहता है:

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

और एक UIColor जो कुछ रंगों गहरा और कुछ रंगों हल्का है। क्या किसी को भी यह करना आता है? धन्यवाद।

Comments

"ढाल" से तात्पर्य है कि आपकी छवि का एक भाग रंग की एक छाया होगी जबकि दूसरा भाग एक गहरा या हल्का शेड होगा। क्या यह परिभाषित करने का एक और तरीका है कि आप क्या करना चाहते हैं?

— माइकल डुटरमैन

इस पुस्तकालय पर एक नज़र

— डालिए

ह्यू संतृप्ति और हल्कापन stackoverflow.com/a/30012117/2303865

— लियो डबस

Answer 1

- (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 : जैसा कि @ अचू चिमाला ने बताया, अधिकतम लचीलेपन के लिए, इन तरीकों को यूआईसीकलर श्रेणी के रूप में लागू किया जाना चाहिए। इसके अलावा, @ रिले के विचार से, निरंतर मूल्यों को जोड़ने या घटाने के बजाय रंगीन रूप से गहरा या हल्का बनाने के लिए यह एक बेहतर विचार हो सकता है। जैसा कि @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

Comments

आरजीबी का उपयोग क्यों करें जब आप ह्यू, संतृप्ति, चमक के साथ ऐसा कर सकते हैं, तो बस चमक के साथ रंग को फिर से बनाएं?

— जर्थर्टन

मैं खुद HSB संस्करण के साथ कोशिश कर रहा हूँ, और यह उम्मीद के मुताबिक काम नहीं किया। getHue:saturation:brightnessUIKit के हस्ताक्षर के बावजूद , ऐसा लगता है कि यह HSB के बजाय HSV के साथ काम करता है। इस संदर्भ में चमक को बदलना (इसलिए वास्तव में, मूल्य) काम नहीं करेगा। उदाहरण के लिए शुद्ध लाल (आरजीबी (255,0,0)) में 1 की चमक / मूल्य होगा, इस प्रकार चमक के माध्यम से प्रकाश को असंभव बनाना। मैंने इसके बजाय RGB मानों में परिवर्तन के साथ काम करना समाप्त कर दिया।

— rachmpourlier

मुझे लगता है कि आपके उत्तर में कुछ गड़बड़ है: आप दो दृष्टिकोण लेते हैं (आरजीबी के साथ एक, और श्रेणी संस्करण के लिए एचएसबी के साथ दूसरा), जिसका परिणाम समान नहीं है ... और यह एक सवाल हो सकता है अर्थ: लाइटनिंग वास्तव में मेरे लिए रंग को सफेद (काला करने के लिए काला करना) कर रही है, जबकि चमक / मूल्य को बदलते हुए इसे मजबूत बना रही है (सम्मान हल्का)।

— rachmpourlier

यदि वे ग्रे शेड्स पर उपयोग किए जाते हैं तो यह विधियाँ विफल हो जाएंगी। getHue:saturation:brightness:alphaFALSE लौटेगा।

— मैथ्यू रीगलर

मुझे आश्चर्य है कि यह स्वीकृत उत्तर क्यों है क्योंकि दोनों सुझाए गए समाधान गलत हैं । वे दोनों केवल सैद्धांतिक मूल्यों को बदल देते हैं जिनका मानव के or लाइटर ’या er गहरे’ रंगों के रूप में अनुभव के साथ बहुत कम है। मैं इस महान पोस्ट को पढ़ने की सलाह देता हूं (शॉर्टलिंक: goo.gl/qqgk9V) जो मेरे कहने का मतलब है उसे समझने के लिए। यह बताता है कि luminanceLAB रंग स्थान का मूल्य सही है जिसे आपको रंग हल्का / गहरा बनाते समय ध्यान रखना चाहिए। आप इसका उपयोग कैसे कर सकते हैं और इस समस्या को सही तरीके से कैसे हल कर सकते हैं, इस पर मेरा उत्तर देखें ।

— जीहुत

Answer 2

टी एल; डॉ:

स्विफ्ट:

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

उद्देश्य सी:

- (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 समाधान ब्रिगनेस स्केल में रंग को किनारे के करीब लाता है - जो मूल रूप से काले रंग से शुरू होता है और शुद्ध रंग के साथ समाप्त होता है ...

मूल रूप से चमक (मूल्य) रंग को कम या अधिक काले रंग के करीब बनाता है, जहां संतृप्ति इसे कम या अधिक सफेद के करीब बनाती है ...

जैसा कि यहां देखा गया है:

तो एक रंग वास्तव में उज्जवल बनाने के लिए समाधान (यानी सफेद के करीब ...) यह संतृप्ति मूल्य छोटा करने के लिए किया जाएगा , जिसके परिणामस्वरूप समाधान:

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

Comments

रंगों को हल्का बनाने के बारे में: मुझे संतृप्ति को कम करने और चमक / मूल्य बढ़ाने से सबसे अच्छा परिणाम मिला। यह उत्तर छवि में पाई के "शीर्ष पर" रंगों के लिए बहुत अच्छा काम करता है। लेकिन अधिकांश रंग पाई के अंदर "अंदर" कहीं गिरने वाले हैं। उन्हें सफेद के करीब लाने के लिए उन्हें "ऊपर" और साथ ही बढ़ते मूल्य की आवश्यकता होती है।

— Pejalo

बढ़ते मूल्य काम करने के लिए प्रकट हो सकते हैं, लेकिन यह "हल्का रंग प्राप्त करें" की "कोर" कार्यक्षमता नहीं होगी। उसी तरह, गहरा रंग पाने के लिए, सही दृष्टिकोण केवल "मूल्य" को कम करना होगा और संतृप्ति को जिस तरह से छोड़ना होगा ...

— Aviel Gross

Answer 3

स्विफ्ट के लिए सार्वभौमिक विस्तार iOS और ओएस एक्स , का उपयोग कर 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()

नमूना:

Comments

मुझे एक त्रुटि मिली: -गूना: संतृप्ति: चमक: अल्फा: NSColor NSCalibratedWhiteColorSpace 0 1 के लिए मान्य नहीं; पहले कलरस्पेस बदलने की जरूरत है।

— Besi

इसे जोड़कर ठीक करें: let color = usingColorSpaceName(NSCalibratedRGBColorSpace) और फिर getHueकॉल को कॉल करने के लिए रंग से color?.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)

— Oskar

_शब्द राशि से पहले फ़ंक्शन गायब है । होना चाहिएprivate func hueColorWithBrightnessAmount(_ amount: CGFloat) -> PXColor {

— कोडमेक

मैं उत्तर में @Oskar का सुझाव जोड़ने का सुझाव देता हूं। इसने मेरे लिए एक रनटाइम क्रैश को ठीक किया।

— बेसी

Answer 4

मैं सिर्फ आरजीबी में, की तुलना में एक ही परिणाम देना चाहता था

• हल्का करने के लिए सफेद पृष्ठभूमि पर अल्फा 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
        )
    }
}

यहाँ कुछ रंगों के साथ उदाहरण दिए गए हैं

Comments

मुझे लगता है कि यह एक बाहरी पुस्तकालय का सहारा लेने के बिना सबसे अच्छा कार्यान्वयन है जो एचएसएल रंग अंतरिक्ष को लागू करता है

— गॉग

Answer 5

उपयोगकर्ता 529758 स्विफ्ट में समाधान:

गहरा रंग:

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

Comments

यह एक अच्छा उत्तर है, सिवाय इसके कि यह अधिक सुविधाजनक होगा क्योंकि इसे केवल var darker: UIColorउदाहरण के लिए यूआईसीकलर वर्ग के विस्तार के रूप में घोषित किया गया था ।

— ब्रूनो फिलिप 13

Answer 6

यदि आप RGB रंग को HSL रंग मॉडल में बदलते हैं तो आप L = 0.0 (काला) से L = 0.5 (प्राकृतिक रंग) से L = 1.0 (सफ़ेद) पर L = लाइटनेस घटक को भिन्न कर सकते हैं। UIColorसीधे HSL को संभाल नहीं सकते, लेकिन RGB <-> HSL को परिवर्तित करने के सूत्र हैं।

Comments

HSL नहीं, लेकिन HSB ठीक है: developer.apple.com/library/ios/documentation/uikit/reference/… :

— jrturton

एचएसएल और एचएसबी (जिसे कभी-कभी एचएसवी भी कहा जाता है) रंग मॉडल के बीच का अंतर यह है कि एचएसबी एल = 1.0 में शुद्ध रंग से मेल खाती है, जबकि एचएसएल एल = 1.0 में सफेद और एल = 0.5 से शुद्ध रंग से मेल खाती है। चूंकि मूल पोस्टर ने उदाहरण के लिए रंग नीला (RGB = 0/0/1) हल्का बनाने के लिए पूछा, मुझे लगता है कि HSL अधिक लचीला है।

— मार्टिन आर

Answer 7

समाधानों में से कोई भी पोस्ट सभी रंगों और रंगों के लिए काफी काम नहीं किया, लेकिन फिर मैं इस पुस्तकालय में ठोकर खाई जो यूआईसीकल को बहुत अच्छी तरह से कार्यान्वित एक्सटेंशन का एक सेट प्रदान करता है।

विशेष रूप से इसका एचएसएल कार्यान्वयन के हिस्से के रूप में एक हल्का कार्य है: (UIColor *)lighten:(CGFloat)amount- जो पूरी तरह से काम करता है।

Answer 8

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

Answer 9

यदि आप चाहते हैं कि उपयोगकर्ता 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।

Answer 10

यूआईसीकलर एक्सटेंशन और फिक्सिंग लाइटरकोलरफॉरकोल

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

Answer 11

इस थ्रेड के अन्य सभी उत्तर या तो RGB रंग प्रणाली का उपयोग करते हैं या केवल HSB सिस्टम के रंग या चमक मान को बदलते हैं । जैसा कि विस्तार से बताया गया है इस महान ब्लॉग पोस्टरंग को हल्का या गहरा बनानेका सही तरीका इसकाluminanceमूल्यबदलना है। अन्य कोई भी उत्तर ऐसा नहीं करता है। अगर आप इसे सही तरीके से करना चाहते हैं, तो मेरे समाधान का उपयोग करें याब्लॉग पोस्ट पढ़ने के बाद अपना खुद का लिखें।

---

दुर्भाग्य से यह डिफ़ॉल्ट रूप से UIColor की किसी भी विशेषता को बदलने के लिए काफी परेशानी है । इसके अलावा Apple किसी भी LAB- आधारित रंग स्थान का समर्थन नहीं करता है जैसे कि HCL वर्ग में ( LAB में वह मान है जिसकी हम तलाश कर रहे हैं)।UIColorLluminance

का उपयोग करते हुए 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 आपके प्रोजेक्ट में कुछ अन्य उपयोगी UI सुविधाएँ भी जोड़ता है - अधिक जानकारी के लिए GitHub पर इसकी README की जाँच करें।

मुझे उम्मीद है यह मदद करेगा!

Comments

अपने ऐप के लिए मैं मैप्स पर रूट बनाता हूं। मैं 100% चमक के साथ एक रंग के अंदर की रेखा के साथ मार्ग को आकर्षित करना चाहता था और उस रंग के गहरे संस्करण के साथ सीमा। क्योंकि अंदर की रेखा में पहले से ही 100% चमक थी कोई भी विधि काम नहीं करती थी। इसके अलावा ऊपर उल्लिखित की तरह चमक को बदलने से चाल नहीं चली। हालांकि, यह बहुत अच्छा विस्तार का उपयोग कर चमक को कम करने ने मेरे लिए चाल चली। 'color.change (.brightness, द्वारा: -0.5)' यह एक्सटेंशन उपयोग में बहुत लचीला है और इसमें बहुत सारे विकल्प हैं। मेरा सुझाव है कि, खासकर यदि आपके पास कई थीम या रंग पट्टियों वाला ऐप है।

— गुइडो

Answer 12

मुझे यकीन नहीं है कि आप किसी प्रकार के ऑब्जेक्टिव-सी उत्तर की तलाश कर रहे हैं, लेकिन आरजीबीए द्वारा निर्दिष्ट रंगों के आधार पर, मुझे लगता है कि आप "लाइटर" प्राप्त करने के लिए मनमाने ढंग से कारक के अनुसार आरजीबी मूल्यों को माप सकते हैं। "गहरा" छाया। उदाहरण के लिए, आपके पास एक नीला रंग हो सकता है:

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

क्या आप उस प्रभाव को देख रहे हैं?

Comments

ठीक है हाँ, जो मुझे चाहिए उसका आधा हिस्सा है। क्या एक हल्का रंग प्राप्त करने का एक तरीका है जब नीला 1 (अधिकतम) है

— कोरकोड

@CoreCode नहीं, वास्तव में नहीं। जब तक आप डिवाइस की स्क्रीन के बर्थनेस को बदलना नहीं चाहते हैं :) मेरा जवाब देखें।

Answer 13

IOS 12 के लिए स्विफ्ट 4.x के साथ Xcode 10 में परीक्षण किया गया

UIColor के रूप में अपने रंग से शुरू करें और एक काले कारक को चुनें (CGFloat के रूप में)

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

प्रकार CGColor का एक वैकल्पिक मूल्य होता है componentsजो RGBA में रंग को तोड़ता है (0 और 1 के बीच के मान के साथ CGFloat सरणी के रूप में)। फिर आप CGColor से RGBG मानों का उपयोग करके एक UIColor को फिर से संगठित कर सकते हैं और उनमें हेरफेर कर सकते हैं।

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

इस उदाहरण में, आरजीबी वैल्यूज़ में से प्रत्येक को 2 से विभाजित किया गया था, जिससे रंग पहले की तरह आधा हो गया। अल्फा वैल्यू वही रही, लेकिन आप वैकल्पिक रूप से RGB के बजाय अल्फा वैल्यू पर डार्कन फैक्टर लागू कर सकते हैं।

Answer 14

स्विफ्ट 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


     }
    }
}

Answer 15

आदर्श रूप से, फ़ंक्शंस को 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()
  }

}

Answer 16

मैं एक मूल्य के आधार पर रंगीन कोशिकाओं को प्रस्तुत करता हूं:

इसके लिए मैंने कुछ पुराने 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।

Answer 17

यहाँ एक 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;
}

Answer 18

@ स्विडडाउन जवाब के आधार पर एक स्विफ्ट एक्सटेंशन:

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

Answer 19

गहरे रंग के लिए, यह सबसे सरल है: TheColor = [theColor shadowWithLevel: s]; //s.0.0 से 1.0

Comments

यह विधि केवल NSColor पर उपलब्ध है, UIColor पर नहीं।

— 06