CGColor e CGColorSpace: cosa sono, modelli di colore e come gestirli

Cosa sono CGColor e CGColorSpace?

CGColor è un oggetto fondamentale di Core Graphics che rappresenta un colore. La struttura CGColor memorizza valori numerici dei componenti di colore e un riferimento a CGColorSpace — lo spazio colore in cui questi componenti vengono interpretati. Senza essere legato a uno spazio colore, i valori numerici dei componenti non hanno significato: il valore (1.0, 0.0, 0.0) in RGB è rosso, ma in CMYK è ciano.

CGColorSpace è un oggetto che definisce un modello di colore e l'intervallo di valori rappresentabili (gamut). Lo spazio colore stabilisce le regole in base alle quali i componenti numerici si trasformano in un colore visibile su un dispositivo di output specifico. Core Graphics supporta sia spazi standard con profilo ICC che spazi personalizzati creati tramite CGColorSpace con tabelle di trasformazione personalizzate.

L'architettura che separa il colore dallo spazio colore è una caratteristica chiave di Core Graphics che lo distingue dalle API in cui il colore viene memorizzato come un semplice insieme di numeri. Questo approccio consente a Core Graphics di eseguire una gestione del colore indipendente dal dispositivo: lo stesso oggetto CGColor può essere visualizzato correttamente su display diversi grazie alla conversione automatica dei componenti tramite il profilo CGColorSpace.

Come funzionano i colori in Core Graphics

Core Graphics implementa il colore attraverso un modello basato su profili ICC (International Color Consortium). Ogni CGColorSpace contiene un riferimento a un profilo ICC — una descrizione standardizzata di come i componenti di colore vengono convertiti in CIE XYZ — uno spazio colore indipendente dal dispositivo. Questo consente a Core Graphics di eseguire una compensazione colorimetrica automatica tra schermi diversi.

Ciclo di vita di un oggetto CGColor

Quando si crea un CGColor tramite la funzione CGColorCreate, i componenti vengono catturati dall'array passato e legati al CGColorSpace specificato. Core Graphics copia i componenti in una rappresentazione interna e crea un'associazione con lo spazio colore. Successivamente, il colore è pronto per essere utilizzato in qualsiasi operazione grafica — riempimento, tracciato, gradiente, ombra.

Gestione del colore tramite ColorSync

Su macOS, la gestione del colore è gestita tramite il framework ColorSync, integrato in Core Graphics. ColorSync tiene traccia della calibrazione del display e converte automaticamente i componenti dallo spazio colore di origine allo spazio del dispositivo di destinazione. Su iOS, la gestione del colore è implementata tramite Quartz Core con supporto per un'ampia gamma cromatica (Display P3), a partire da iPhone 7.

Modelli di colore di base in CGColorSpace

CGColorSpace supporta quattro modelli di colore di base: RGB (DeviceRGB, sRGB, Display P3), Gray (DeviceGray), CMYK (DeviceCMYK) e Lab. Ogni modello definisce il numero e il significato dei componenti di colore. RGB utilizza tre canali — rosso, verde, blu; Gray utilizza un canale di luminanza; CMYK utilizza quattro canali per la stampa; Lab utilizza tre canali: luminanza e due componenti di differenza di colore.

DeviceRGB e sRGB

DeviceRGB è lo spazio colore predefinito più comune di Core Graphics. Utilizza la gamma cromatica di un display LCD standard senza profilatura ICC. Quando si crea un contesto grafico UIView o NSView, Core Graphics assegna automaticamente DeviceRGB come spazio colore predefinito. sRGB è una versione profilata ICC con gamma e gamma fissi, raccomandata per i contenuti web.

Display P3 — Ampia gamma cromatica

Display P3 è uno spazio colore basato sullo standard DCI-P3, utilizzato nei moderni dispositivi iOS con display a gamma cromatica estesa. Copre circa il 25% in più di colori visibili rispetto a sRGB, specialmente nelle aree verdi e rosse dello spettro. Per lavorare con Display P3 su iOS, utilizzare la costante kCGColorSpaceDisplayP3, disponibile da iOS 9.3.

Creazione e gestione di CGColor

CGColor viene creato tramite la funzione CGColorCreate, che riceve un CGColorSpace e un array di componenti CGFloat. Il numero di componenti dipende dal modello di colore: 1 per Gray, 3 per RGB, 4 per CMYK. Una volta creato, CGColor è un oggetto immutabile — non è possibile modificare i suoi componenti, ma solo creare un nuovo colore.

Core Graphics fornisce anche le funzioni CGColorCreateGenericRGB, CGColorCreateGenericGray e CGColorCreateGenericCMYK per creare colori in spazi colore standard (generici). Queste funzioni semplificano il codice eliminando la necessità di creare esplicitamente un CGColorSpace. Inoltre, Quartz 2D definisce costanti per i colori di base: kCGColorWhite, kCGColorBlack, kCGColorClear.

Quando si crea un colore, l'ordine di specifica dei componenti è importante — deve corrispondere rigorosamente all'ordine dei canali definito dal modello di spazio colore. RGB: rosso (0.0–1.0), verde, blu, alfa (0.0–1.0). Gray: luminanza, alfa. CMYK: ciano, magenta, giallo, nero, alfa. Violare l'ordine dei componenti porta a una visualizzazione errata del colore senza errore di compilazione.

Canale alfa e trasparenza

Il canale alfa è il quarto componente (o il secondo per Gray) che controlla la trasparenza del colore. Il valore 1.0 corrisponde all'opacità totale, 0.0 alla trasparenza totale. Il canale alfa in CGColor è opzionale: la funzione CGColorGetAlpha restituisce il valore alfa corrente, che per impostazione predefinita è 1.0 quando viene creato tramite funzioni di base. Quando si mescolano i colori, Core Graphics utilizza l'alpha compositing secondo la regola Porter-Duff Source Over.

Lavorare con CGColorSpace

CGColorSpace viene creato tramite le funzioni factory di Core Graphics: CGColorSpaceCreateDeviceRGB, CGColorSpaceCreateDeviceGray, CGColorSpaceCreateDeviceCMYK o CGColorSpaceCreateWithName per spazi denominati (sRGB, Display P3, Generic Gray). L'oggetto CGColorSpace è immutabile e thread-safe — lo stesso oggetto può essere utilizzato in più contesti grafici.

Ottenere CGColorSpace di base

Core Graphics fornisce diversi spazi colore predefiniti tramite costanti denominate: kCGColorSpaceSRGB, kCGColorSpaceDisplayP3, kCGColorSpaceGenericGrayGamma2_2. Queste costanti vengono passate a CGColorSpaceCreateWithName. Per i dispositivi iOS con ampia gamma cromatica, si consiglia Display P3, poiché sRGB potrebbe non utilizzare pienamente le capacità del display.

Profili ICC e CGColorSpace personalizzati

I profili ICC sono file standardizzati che descrivono le caratteristiche cromatiche di un dispositivo. Core Graphics consente di creare un CGColorSpace basato su un profilo ICC arbitrario tramite CGColorSpaceCreateWithICCProfile. Questo viene utilizzato in applicazioni professionali per la stampa fotografica e la prestampa dove è richiesta una corrispondenza precisa con una specifica stampante o monitor.

Conversione tra spazi colore

Core Graphics esegue la conversione tra spazi colore automaticamente durante il rendering tramite le funzioni CGContextSetFillColorWithColor o CGContextSetStrokeColorWithColor. Se lo spazio colore del contesto grafico differisce dallo spazio colore del CGColor passato, Quartz 2D esegue la conversione utilizzando i profili ICC di entrambi gli spazi.

Per la conversione esplicita del colore, utilizzare CGColorCreateCopyByMatchingToColorSpace — una funzione che crea un nuovo CGColor i cui componenti vengono ricalcolati dallo spazio di origine allo spazio di destinazione. Secondo Apple Technical Note TN2313 (2024), quando si converte da Display P3 a sRGB, i colori al di fuori del gamut sRGB vengono ritagliati, con conseguente perdita di saturazione. Ciò è particolarmente evidente nelle tonalità verde e rosso brillanti.

ColorSync su macOS fornisce una gestione del colore a livello di sistema nello stack grafico. Se un'applicazione non specifica uno spazio colore esplicito, Core Graphics utilizza lo spazio del display ottenuto da ColorSync. Ciò garantisce che i colori appaiano uguali su monitor diversi, anche se utilizzano profili colore differenti.

Esempi di codice Swift

Vediamo esempi pratici di creazione e utilizzo di CGColor e CGColorSpace in un'applicazione iOS. Il codice è scritto in Swift utilizzando le funzioni di Core Graphics.

Creazione di CGColor con diversi spazi colore

Questo esempio mostra la creazione di un colore rosso in tre diversi spazi colore. Nonostante gli stessi componenti RGB, il colore apparirà diverso a seconda del gamut del CGColorSpace.

import CoreGraphics

// Creazione colore in DeviceRGB
let rgbSpace = CGColorSpaceCreateDeviceRGB()
let redColor = CGColorCreate(rgbSpace, [1.0, 0.0, 0.0, 1.0])

// Creazione colore in Display P3
let p3Space = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3)
let p3RedColor = CGColorCreate(p3Space, [1.0, 0.0, 0.0, 1.0])

// Creazione colore grigio
let graySpace = CGColorSpaceCreateDeviceGray()
let grayColor = CGColorCreate(graySpace, [0.5, 1.0])

Conversione del colore tra spazi colore

Questo esempio converte un colore verde brillante da Display P3 a sRGB. Durante tale conversione, i colori al di fuori del gamut sRGB verranno adattati, il che potrebbe modificare la tonalità.

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

// Verde brillante in Display P3 (fuori dal gamut sRGB)
let p3Green = CGColorCreate(p3Space, [0.0, 1.0, 0.0, 1.0])

// Conversione in sRGB
let srgbGreen = CGColorCreateCopyByMatchingToColorSpace(
    sRGBSpace, p3Green, kCGRenderingIntentDefault
)

Utilizzo di CGColor in un contesto grafico

Questo esempio dimostra il disegno di un cerchio riempito utilizzando CGColor in un UIView personalizzato. Il metodo draw ottiene il contesto grafico corrente UIGraphicsGetCurrentContext, in cui viene impostato il colore di riempimento.

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