Heller und dunkler Farbe, Variationen für ein bestimmtes UIColor

Wie man die verschiedenen helleren und dunkleren Variationen eines bestimmten UIColor in Swift?

Titel Frage ist ziemlich trivial und erlauben unterschiedliche Lösungen; Sie können auch eine einzelne Funktion verwenden statt zwei mit negativen input-parameter
Verschiedene Techniken wurden vorgeschlagen, hier stackoverflow.com/questions/11598043/..., dort sind auch Antworten in Swift.
aktualisiert, danke für den input
Swift - 4.0 Klicken Sie auf " Hase für die Antwort
die Antwort war schon in der Zeit, die Sie Ihre Frage veröffentlicht. Im Allgemeinen denke ich, dass diese Frage und die anderen sind sehr ähnlich, wenn nicht dupliziert.
Möglich, Duplikat der Etwas Hellere und eine Dunklere Farbe aus UIColor

InformationsquelleAutor Stephen | 2016-07-18

107

Aktualisiert

Unter UIColor-Erweiterung:
```
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 red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0
        if self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {
            return UIColor(red: min(red + percentage/100, 1.0),
                           green: min(green + percentage/100, 1.0),
                           blue: min(blue + percentage/100, 1.0),
                           alpha: alpha)
        } else {
            return nil
        }
    }
}
```
Verwendung:
```
let color = UIColor(red:0.96, green:0.54, blue:0.10, alpha:1.0)
color.lighter(30) //returns lighter color by 30%
color.darker(30) // returns darker color by 30%
```
statt .lighter() und .darker() verwenden, können Sie .adjust() mit positiven Werten für die Aufhellung und negative Werte für Verdunkelung
```
color.adjust(-30) //30% darker color
color.adjust(30) // 30% lighter color
```
Ausgabe:
- Ändern Sie alle Komponenten durch den gleichen Wert, anstelle der änderung proportional. Sehen Sie, wie orange wird gelb, wenn Sie machen es heller.
- Hinzufügen von Werten proportional nicht korrekt. versuchen Sie, diese Farbe UIColor(rot:0.89, grün:0.28, blau:0.00, alpha:1.0)
- Aber das hinzufügen der gleiche Wert für alle Komponenten ist nicht korrekt, es ändert sich die Farbe. Haben Sie einen Blick auf die verschiedenen Antworten zu den stackoverflow.com/questions/11598043/..., wo der Helligkeit in der HSB-Darstellung eingestellt ist.
- Ich habe ausgeführt, Ihre Funktion und mine, beide Ausgänge sind gleich(orange nicht gelb werden 😉 ). Aber ich brauche zum verbessern der Fertigkeit im code reduzieren. ich sollte vermieden Umwandlung der RGB-Werte und schreiben von Logik in Funktion. update der code
- Ich glaube für schwarz leichter , gibt die grüne Farbe
- Was bedeutet die =30.0 bedeuten in der Deklaration der Funktion func ...(by percentage:CGFloat=30.0)
- Sie wahrscheinlich wissen, von jetzt, aber = setzt den default-Wert.
- Funktioniert wie Charme
- Für jeden dieser Auftritt für dunkle Farben... erzeugt negative Werte, wenn verwendet, zu verdunkeln, die scheint in Ordnung, in einigen Fällen, in anderen Fällen aber zeigt, wie hell, dass die Farben - z.B. UIColor.Braun.dunkler(), welche endet als RGB-0.3 0.1 -0.1, ist die Anzeige wie royal blau in SKShapeNode ist die Füllfarbe. Zu beheben, fügen Sie max(x, 0) überprüft, z.B. "blau: max(min(blau + Prozentsatz/100, 1.0), 0.0)"
InformationsquelleAutor Stephen

Möchte ich eine andere version mit Helligkeit & Sättigung statt RGB

extension UIColor {
  /**
   Create a ligher color
   */
  func lighter(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: abs(percentage))
  }

  /**
   Create a darker color
   */
  func darker(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: -abs(percentage))
  }

  /**
   Try to increase brightness or decrease saturation
   */
  func adjustBrightness(by percentage: CGFloat = 30.0) -> UIColor {
    var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
    if self.getHue(&h, saturation: &s, brightness: &b, alpha: &a) {
      if b < 1.0 {
        let newB: CGFloat = max(min(b + (percentage/100.0)*b, 1.0), 0.0)
        return UIColor(hue: h, saturation: s, brightness: newB, alpha: a)
      } else {
        let newS: CGFloat = min(max(s - (percentage/100.0)*s, 0.0), 1.0)
        return UIColor(hue: h, saturation: newS, brightness: b, alpha: a)
      }
    }
    return self
  }
}

Ich denke, das ist besser als das ändern der RGB-Werte
Glaube nicht, dass dies funktioniert, wenn die Sättigung auf 0 und die Helligkeit 1.0. IE weiß. In diesem Fall werden Sie am Ende mit unverändert Sättigung.

InformationsquelleAutor Tran Quan

Version mit den RGB-Werten Modifikation

Hier habe ich einfach UIColor - Erweiterung, die basierend auf früheren Antworten. Es funktioniert perfekt für mich.

Unten demo:

Heller und dunkler Farbe, Variationen für ein bestimmtes UIColor

Farben manipulation code

public extension UIColor {

    /**
     Create a lighter color
     */
    public func lighter(by percentage: CGFloat = 30.0) -> UIColor {
        return self.adjustBrightness(by: abs(percentage))
    }

    /**
     Create a darker color
     */
    public func darker(by percentage: CGFloat = 30.0) -> UIColor {
        return self.adjustBrightness(by: -abs(percentage))
    }

    /**
     Changing R, G, B values
     */

    func adjustBrightness(by percentage: CGFloat = 30.0) -> UIColor {

        var red: CGFloat = 0.0
        var green: CGFloat = 0.0
        var blue: CGFloat = 0.0
        var alpha: CGFloat = 0.0

        if self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {

            let pFactor = (100.0 + percentage) / 100.0

            let newRed = (red*pFactor).clamped(to: 0.0 ... 1.0)
            let newGreen = (green*pFactor).clamped(to: 0.0 ... 1.0)
            let newBlue = (blue*pFactor).clamped(to: 0.0 ... 1.0)

            return UIColor(red: newRed, green: newGreen, blue: newBlue, alpha: alpha)
        }

        return self
    }
}

Eingespannt Funktion
Erweiterung einfach zu halten Werte zwischen min und max.

extension Comparable {

    func clamped(to range: ClosedRange<Self>) -> Self {

        if self > range.upperBound {
            return range.upperBound
        } else if self < range.lowerBound {
            return range.lowerBound
        } else {
            return self
        }
    }
}

InformationsquelleAutor lukszar

Für Swift 5.0 :

extension UIColor {

func lighter(by percentage: CGFloat = 10.0) -> UIColor {
    return self.adjust(by: abs(percentage))
}

func darker(by percentage: CGFloat = 10.0) -> UIColor {
    return self.adjust(by: -abs(percentage))
}

func adjust(by percentage: CGFloat) -> UIColor {
    var alpha, hue, saturation, brightness, red, green, blue, white : CGFloat
    (alpha, hue, saturation, brightness, red, green, blue, white) = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

    let multiplier = percentage / 100.0

    if self.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha) {
        let newBrightness: CGFloat = max(min(brightness + multiplier*brightness, 1.0), 0.0)
        return UIColor(hue: hue, saturation: saturation, brightness: newBrightness, alpha: alpha)
    }
    else if self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {
        let newRed: CGFloat = min(max(red + multiplier*red, 0.0), 1.0)
        let newGreen: CGFloat = min(max(green + multiplier*green, 0.0), 1.0)
        let newBlue: CGFloat = min(max(blue + multiplier*blue, 0.0), 1.0)
        return UIColor(red: newRed, green: newGreen, blue: newBlue, alpha: alpha)
    }
    else if self.getWhite(&white, alpha: &alpha) {
        let newWhite: CGFloat = (white + multiplier*white)
        return UIColor(white: newWhite, alpha: alpha)
    }

    return self
    }
}

InformationsquelleAutor MichelRobico

Kenji-Tran Antwort funktioniert gut, solange Ihr Ausgangspunkt ist die Farbe nicht schwarz (Helligkeit 0). Mit der Zugabe von ein paar Zeilen extra-code, können Sie auch schwarz "heller" (also erhellen Sie die Graustufen oder Farbwerte).

Hinweis: ich war nicht in der Lage, fügen Sie diese änderung mit einem Bearbeiten und darf ich nicht kommentieren Kenji-Tran ' s Antwort wegen meiner "neuen Jungen" rep, deshalb habe ich keinen anderen Weg gefunden, mein wissen zu teilen auf, DAMIT dann durch die Veröffentlichung einer neuen Antwort. Ich hoffe, das ist okay.

extension UIColor {
  /**
   Create a ligher color
   */
  func lighter(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: abs(percentage))
  }

  /**
   Create a darker color
   */
  func darker(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: -abs(percentage))
  }

  /**
   Try to increase brightness or decrease saturation
   */
  func adjustBrightness(by percentage: CGFloat = 30.0) -> UIColor {
    var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
    if self.getHue(&h, saturation: &s, brightness: &b, alpha: &a) {
      if b < 1.0 {
        /**
         Below is the new part, which makes the code work with black as well as colors
        */
        let newB: CGFloat
        if b == 0.0 {
            newB = max(min(b + percentage/100, 1.0), 0.0)
        } else {
            newB = max(min(b + (percentage/100.0)*b, 1.0), 0,0)
        }
        return UIColor(hue: h, saturation: s, brightness: newB, alpha: a)
      } else {
        let newS: CGFloat = min(max(s - (percentage/100.0)*s, 0.0), 1.0)
        return UIColor(hue: h, saturation: newS, brightness: b, alpha: a)
      }
    }
    return self
  }
}

Vielen Dank für den Hinweis auf die fehlenden Fall (y). Darf ich eine Frage stellen? Warum ist es b == 0.0 && s == 0.0? Ich dachte, die wollen nur mehr Fall b == 0 ist genug, um das Problem zu lösen. Denn wenn b is 0 and s > 0 code noch nicht in der Lage sein, um die Farbe ligher?
Gute Frage. Es ist ein Fehler. Ich habe die Feste code. Der Grund, ich habe überprüft, ob s == 0 war, weil ich wollte, dass es Arbeit für schwarz in Graustufen. Aber offensichtlich ohne die s == 0 es funktioniert für eine beliebige Farbe mit Helligkeit null. Danke.

InformationsquelleAutor ChrisDL

Sparen, jemand der Eingabe, die einfache praktische version ist nur

extension UIColor {

    var darker: UIColor {

    var h: CGFloat = 0, s: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0

        guard self.getHue(&h, saturation: &s, brightness: &b, alpha: &a) else {
            print("** some problem demuxing the color")
            return .gray
        }

        let nudged = b * 0.5

        return UIColor(hue: h, saturation: s, brightness: nudged, alpha: a)
    }
}

verwenden, wie

something.color = .yellow.darker

oder

backgroundColor = backgroundColor.darker

Ein großes Projekt .................

Sollten Sie auf jeden Fall erweitern, apples Muster:

.withAlphaComponent(_ alpha: CGFloat)

So, haben:

.withBrightnessComponent(_ alpha: CGFloat)

klar und deutlich

.withBrightnessComponentAdjustedBy(percentage: CGFloat)

und/oder

.withBrightnessComponentMultipliedBy(factor: CGFloat)

InformationsquelleAutor Fattie

0

Getestet in Xcode 10 Swift-4.x für iOS-12

Beginnen Sie mit Ihrer Farbe wie ein UIColor und wählen Sie eine Verdunkelung Faktor (als CGFloat)
```
let baseColor = UIColor.red
let darkenFactor: CGFloat = 2
```
Art CGColor hat einen optionalen Wert components die brechen die Farbe in RGBA (als CGFloat array mit Werten zwischen 0 und 1). Sie können dann rekonstruieren, eine UIColor mit RGBA-Werte aus den CGColor und manipulieren.
```
let darkenedBase = UIColor(displayP3Red: startColor.cgColor.components![0] / darkenFactor, green: startColor.cgColor.components![1] / darkenFactor, blue: startColor.cgColor.components![2] / darkenFactor, alpha: 1)
```
In diesem Beispiel wird jedes der RGB-valuse wurden durch 2 geteilt, wodurch die Farbe halb so dunkel, wie es vorher war. Der alpha-Wert gleich geblieben, aber man konnte alternativ tragen Sie die dunkler-Faktor auf der alpha-Wert eher als der RGB.

InformationsquelleAutor Microbob

Mit lukszar clampled Funktion, schrieb ich diese Funktion für die UIColor-Erweiterung, mit den realen Proportionen der RGB-Werte. Ich hoffe, es ist hilfreich

public extension UIColor {

  public func lighter(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: abs(percentage))
  }

  public func darker(by percentage: CGFloat = 30.0) -> UIColor {
    return self.adjustBrightness(by: -abs(percentage))
  }

  func adjustBrightness(by percentage: CGFloat = 30.0) -> UIColor {

    let ratio = percentage/100

    var red:   CGFloat = 0.0
    var green: CGFloat = 0.0
    var blue:  CGFloat = 0.0
    var alpha: CGFloat = 0.0

    if self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {
      let newRed =   (red   + ((ratio < 0) ? red   * ratio : (1 - red)   * ratio)).clamped(to: 0.0 ... 1.0)
      let newGreen = (green + ((ratio < 0) ? green * ratio : (1 - green) * ratio)).clamped(to: 0.0 ... 1.0)
      let newBlue =  (blue  + ((ratio < 0) ? blue  * ratio : (1 - blue)  * ratio)).clamped(to: 0.0 ... 1.0)
      return UIColor(red: newRed, green: newGreen, blue: newBlue, alpha: alpha)
    }
    return self
  }
}

InformationsquelleAutor Oscar

Swift 4-version, die unterstützt RGBA, HSBA, und WB (Graustufen)

Hier ist eine Variante des TranQuan ist Antwort, dass auch unterstützt Graustufen-Farben wie .white und .black. (Hinweis: ich entfernte die Sättigung Anpassung, da glaube ich nicht, es gehörte in eine einfache Funktion wie diese.)

extension UIColor {
    /**
     Create a ligher color
     */
    func lighter(by percentage: CGFloat = 10.0) -> UIColor {
        return self.adjustBrightness(by: abs(percentage))
    }

    /**
     Create a darker color
     */
    func darker(by percentage: CGFloat = 10.0) -> UIColor {
        return self.adjustBrightness(by: -abs(percentage))
    }

    /**
     Try to adjust brightness and falls back to adjusting colors if necessary
     */
    func adjustBrightness(by percentage: CGFloat) -> UIColor {
        var alpha, hue, saturation, brightness, red, green, blue, white : CGFloat
        (alpha, hue, saturation, brightness, red, green, blue, white) = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)

        let multiplier = percentage / 100.0

        if self.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha) {
            let newBrightness: CGFloat = max(min(brightness + multiplier*brightness, 1.0), 0.0)
            return UIColor(hue: hue, saturation: saturation, brightness: newBrightness, alpha: alpha)
        }
        else if self.getRed(&red, green: &green, blue: &blue, alpha: &alpha) {
            let newRed: CGFloat = min(max(red + multiplier*red, 0.0), 1.0)
            let newGreen: CGFloat = min(max(green + multiplier*green, 0.0), 1.0)
            let newBlue: CGFloat = min(max(blue + multiplier*blue, 0.0), 1.0)
            return UIColor(red: newRed, green: newGreen, blue: newBlue, alpha: alpha)
        }
        else if self.getWhite(&white, alpha: &alpha) {
            let newWhite: CGFloat = (white + multiplier*white)
            return UIColor(white: newWhite, alpha: alpha)
        }

        return self
    }
}

InformationsquelleAutor Warpling

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Aktualisiert

Ein großes Projekt .................