CGColor et CGColorSpace : ce que c'est, modèles de couleur et comment les gérer

Que sont CGColor et CGColorSpace ?

CGColor est un objet fondamental de Core Graphics représentant une couleur. La structure CGColor stocke des valeurs numériques de composants de couleur et une référence à CGColorSpace — l'espace colorimétrique dans lequel ces composants sont interprétés. Sans être lié à un espace colorimétrique, les valeurs numériques des composants n'ont pas de sens : la valeur (1.0, 0.0, 0.0) en RGB est rouge, mais en CMJN est cyan.

CGColorSpace est un objet qui définit un modèle de couleur et la plage de valeurs représentables (gamut). L'espace colorimétrique établit les règles selon lesquelles les composants numériques se transforment en une couleur visible sur un périphérique de sortie spécifique. Core Graphics prend en charge à la fois les espaces standard profilés ICC et les espaces personnalisés créés via CGColorSpace avec des tables de transformation personnalisées.

L'architecture séparant la couleur de l'espace colorimétrique est une caractéristique clé de Core Graphics qui le distingue des API où la couleur est stockée comme un simple ensemble de nombres. Cette approche permet à Core Graphics d'effectuer une gestion des couleurs indépendante du périphérique : le même objet CGColor peut être affiché correctement sur différents écrans grâce à la conversion automatique des composants via le profil CGColorSpace.

Comment les couleurs fonctionnent dans Core Graphics

Core Graphics implémente la couleur via un modèle basé sur les profils ICC (International Color Consortium). Chaque CGColorSpace contient une référence à un profil ICC — une description standardisée de la façon dont les composants de couleur sont convertis en CIE XYZ — un espace colorimétrique indépendant du périphérique. Cela permet à Core Graphics d'effectuer une compensation colorimétrique automatique entre différents écrans.

Cycle de vie d'un objet CGColor

Lors de la création d'un CGColor via la fonction CGColorCreate, les composants sont capturés à partir du tableau passé et liés au CGColorSpace spécifié. Core Graphics copie les composants dans une représentation interne et crée une association avec l'espace colorimétrique. Après cela, la couleur est prête à être utilisée dans toute opération graphique — remplissage, contour, dégradé, ombre.

Gestion des couleurs via ColorSync

Sur macOS, la gestion des couleurs est assurée par le framework ColorSync, intégré à Core Graphics. ColorSync suit l'étalonnage de l'écran et convertit automatiquement les composants de l'espace colorimétrique source vers l'espace du périphérique cible. Sur iOS, la gestion des couleurs est implémentée via Quartz Core avec la prise en charge d'une large gamme de couleurs (Display P3), à partir de l'iPhone 7.

Modèles de couleur de base dans CGColorSpace

CGColorSpace prend en charge quatre modèles de couleur de base : RGB (DeviceRGB, sRGB, Display P3), Gray (DeviceGray), CMYK (DeviceCMYK) et Lab. Chaque modèle définit le nombre et la signification des composants de couleur. RGB utilise trois canaux — rouge, vert, bleu ; Gray utilise un canal de luminance ; CMJN utilise quatre canaux pour l'impression ; Lab utilise trois canaux : luminance et deux composants de différence de couleur.

DeviceRGB et sRGB

DeviceRGB est l'espace colorimétrique par défaut le plus courant de Core Graphics. Il utilise la gamme de couleurs d'un écran LCD standard sans profilage ICC. Lors de la création d'un contexte graphique UIView ou NSView, Core Graphics attribue automatiquement DeviceRGB comme espace colorimétrique par défaut. sRGB est une version profilée ICC avec une gamme et un gamma fixes, recommandée pour le contenu Web.

Display P3 — Large gamme de couleurs

Display P3 est un espace colorimétrique basé sur la norme DCI-P3, utilisé dans les appareils iOS modernes dotés d'écrans large gamme. Il couvre environ 25% de couleurs visibles en plus que le sRGB, en particulier dans les zones vertes et rouges du spectre. Pour travailler avec Display P3 sur iOS, utilisez la constante kCGColorSpaceDisplayP3, disponible depuis iOS 9.3.

Création et gestion de CGColor

CGColor est créé via la fonction CGColorCreate, qui prend un CGColorSpace et un tableau de composants CGFloat. Le nombre de composants dépend du modèle de couleur : 1 pour Gray, 3 pour RGB, 4 pour CMJN. Une fois créé, CGColor est un objet immuable — vous ne pouvez pas modifier ses composants, seulement créer une nouvelle couleur.

Core Graphics fournit également les fonctions CGColorCreateGenericRGB, CGColorCreateGenericGray et CGColorCreateGenericCMYK pour créer des couleurs dans des espaces colorimétriques standard (génériques). Ces fonctions simplifient le code en éliminant la nécessité de créer explicitement un CGColorSpace. De plus, Quartz 2D définit des constantes pour les couleurs de base : kCGColorWhite, kCGColorBlack, kCGColorClear.

Lors de la création d'une couleur, l'ordre de spécification des composants est important — il doit correspondre strictement à l'ordre des canaux défini par le modèle d'espace colorimétrique. RGB : rouge (0.0–1.0), vert, bleu, alpha (0.0–1.0). Gray : luminance, alpha. CMJN : cyan, magenta, jaune, noir, alpha. La violation de l'ordre des composants entraîne un affichage incorrect de la couleur sans erreur de compilation.

Canal alpha et transparence

Le canal alpha est le quatrième composant (ou le second pour Gray) qui contrôle la transparence de la couleur. La valeur 1.0 correspond à une opacité totale, 0.0 à une transparence totale. Le canal alpha dans CGColor est optionnel : la fonction CGColorGetAlpha retourne la valeur alpha actuelle, qui est par défaut 1.0 lors de la création via les fonctions de base. Lors du mélange des couleurs, Core Graphics utilise la composition alpha selon la règle Porter-Duff Source Over.

Travailler avec CGColorSpace

CGColorSpace est créé via les fonctions d'usine de Core Graphics : CGColorSpaceCreateDeviceRGB, CGColorSpaceCreateDeviceGray, CGColorSpaceCreateDeviceCMYK ou CGColorSpaceCreateWithName pour les espaces nommés (sRGB, Display P3, Generic Gray). L'objet CGColorSpace est immuable et thread-safe — le même objet peut être utilisé dans plusieurs contextes graphiques.

Obtention des CGColorSpace de base

Core Graphics fournit plusieurs espaces colorimétriques prédéfinis via des constantes nommées : kCGColorSpaceSRGB, kCGColorSpaceDisplayP3, kCGColorSpaceGenericGrayGamma2_2. Ces constantes sont passées à CGColorSpaceCreateWithName. Pour les appareils iOS à large gamme de couleurs, Display P3 est recommandé car sRGB peut ne pas utiliser pleinement les capacités de l'écran.

Profils ICC et CGColorSpace personnalisés

Les profils ICC sont des fichiers standardisés décrivant les caractéristiques colorimétriques d'un périphérique. Core Graphics permet de créer un CGColorSpace basé sur un profil ICC arbitraire via CGColorSpaceCreateWithICCProfile. Ceci est utilisé dans les applications professionnelles pour l'impression photo et la prépresse où une correspondance précise avec une imprimante ou un moniteur spécifique est requise.

Conversion entre espaces colorimétriques

Core Graphics effectue la conversion entre espaces colorimétriques automatiquement lors du rendu via les fonctions CGContextSetFillColorWithColor ou CGContextSetStrokeColorWithColor. Si l'espace colorimétrique du contexte graphique diffère de l'espace colorimétrique du CGColor passé, Quartz 2D effectue la conversion en utilisant les profils ICC des deux espaces.

Pour une conversion explicite des couleurs, utilisez CGColorCreateCopyByMatchingToColorSpace — une fonction qui crée un nouveau CGColor dont les composants sont recalculés de l'espace source vers l'espace cible. Selon Apple Technical Note TN2313 (2024), lors de la conversion de Display P3 vers sRGB, les couleurs en dehors du gamut sRGB sont écrêtées, ce qui entraîne une perte de saturation. Ceci est particulièrement visible sur les teintes vertes et rouges vives.

ColorSync sur macOS fournit une gestion des couleurs au niveau système dans la pile graphique. Si une application ne spécifie pas d'espace colorimétrique explicite, Core Graphics utilise l'espace d'écran obtenu de ColorSync. Cela garantit que les couleurs auront le même aspect sur différents moniteurs, même s'ils utilisent des profils de couleur différents.

Exemples de code Swift

Regardons des exemples pratiques de création et d'utilisation de CGColor et CGColorSpace dans une application iOS. Le code est écrit en Swift en utilisant les fonctions Core Graphics.

Création de CGColor avec différents espaces colorimétriques

Cet exemple montre la création d'une couleur rouge dans trois espaces colorimétriques différents. Malgré des composants RGB identiques, la couleur aura un aspect différent selon le gamut du CGColorSpace.

import CoreGraphics

// Création de couleur en DeviceRGB
let rgbSpace = CGColorSpaceCreateDeviceRGB()
let redColor = CGColorCreate(rgbSpace, [1.0, 0.0, 0.0, 1.0])

// Création de couleur en Display P3
let p3Space = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3)
let p3RedColor = CGColorCreate(p3Space, [1.0, 0.0, 0.0, 1.0])

// Création de couleur grise
let graySpace = CGColorSpaceCreateDeviceGray()
let grayColor = CGColorCreate(graySpace, [0.5, 1.0])

Conversion de couleur entre espaces colorimétriques

Cet exemple convertit une couleur vert vif de Display P3 vers sRGB. Lors d'une telle conversion, les couleurs en dehors du gamut sRGB seront adaptées, ce qui peut modifier la teinte.

let p3Space = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3)
let sRGBSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB)

// Vert vif en Display P3 (en dehors du gamut sRGB)
let p3Green = CGColorCreate(p3Space, [0.0, 1.0, 0.0, 1.0])

// Conversion en sRGB
let srgbGreen = CGColorCreateCopyByMatchingToColorSpace(
    sRGBSpace, p3Green, kCGRenderingIntentDefault
)

Utilisation de CGColor dans un contexte graphique

Cet exemple démontre le dessin d'un cercle rempli utilisant CGColor dans un UIView personnalisé. La méthode draw obtient le contexte graphique actuel UIGraphicsGetCurrentContext, dans lequel la couleur de remplissage est définie.

class ColorView: UIView {
    override func draw(rect: CGRect) {
        guard let ctx = UIGraphicsGetCurrentContext()
        else { return }

        let rgbSpace = CGColorSpaceCreateDeviceRGB()
        let blueColor = CGColorCreate(
            rgbSpace,
            [0.2, 0.4, 1.0, 1.0]
        )

        ctx.setFillColor(blueColor)
        ctx.fillEllipse(in: CGRect(x: 50, y: 50,
                                  width: 200, height: 200))
    }
}