CGColor și CGColorSpace: ce sunt, modelele de culoare și cum să le gestionăm

Ce sunt CGColor și CGColorSpace?

CGColor — este un obiect fundamental Core Graphics care reprezintă o culoare. În structura CGColor se stochează valorile numerice ale componentelor de culoare și o referință la CGColorSpace — spațiul de culoare în care aceste componente sunt interpretate. Fără legătura la spațiul de culoare, valorile numerice ale componentelor nu au sens: valoarea (1.0, 0.0, 0.0) în RGB este roșu, iar în CMYK este cyan (Cyan).

CGColorSpace — este un obiect care definește modelul de culoare și intervalul valorilor reprezentabile (gamut). Spațiul de culoare stabilește regulile după care componentele numerice se transformă în culoare vizibilă pe un anumit dispozitiv de ieșire. Core Graphics suportă atât spații standard cu profilare ICC, cât și spații personalizate create prin CGColorSpace cu tabele de conversie personalizate.

Arhitectura separării culorii și spațiului de culoare — o caracteristică cheie a Core Graphics care o deosebește de API-urile unde culoarea este stocată ca un simplu set de numere. Această abordare permite Core Graphics să execute gestionarea culorii independentă de hardware: același obiect CGColor poate fi afișat corect pe diferite ecrane datorită conversiei automate a componentelor prin profilul CGColorSpace.

Cum funcționează culorile în Core Graphics

Core Graphics implementează culoarea printr-un model bazat pe profiluri ICC (International Color Consortium). Fiecare CGColorSpace conține o referință la un profil ICC — o descriere standardizată a modului în care componentele de culoare sunt convertite în CIE XYZ — un spațiu de culoare independent de hardware. Acest lucru permite Core Graphics să realizeze compensarea colorimetrică automată între diferite ecrane.

Ciclul de viață al obiectului CGColor

La crearea CGColor prin funcția CGColorCreate are loc captarea componentelor din tabloul transmis și asocierea cu CGColorSpace specificat. Core Graphics copiază componentele în reprezentarea internă și creează o asociere cu spațiul de culoare. După aceasta, culoarea este gata pentru utilizare în orice operațiune grafică — umplere, contur, gradient, umbră.

Gestionarea culorii prin ColorSync

Pe macOS gestionarea culorii se realizează prin framework-ul ColorSync integrat în Core Graphics. ColorSync urmărește calibrarea ecranului și convertește automat componentele din spațiul de culoare al sursei în spațiul dispozitivului țintă. Pe iOS gestionarea culorii este implementată prin Quartz Core cu suport pentru gamut larg de culoare (Display P3), începând cu iPhone 7.

Modelele principale de culoare în CGColorSpace

CGColorSpace suportă patru modele de culoare de bază: RGB (DeviceRGB, sRGB, Display P3), Gray (DeviceGray), CMYK (DeviceCMYK) și Lab. Fiecare model determină numărul și semnificația componentelor de culoare. RGB utilizează trei canale — roșu, verde, albastru; Gray — un canal de luminozitate; CMYK — patru canale pentru imprimare; Lab — trei canale: luminozitate și două componente de diferență de culoare.

DeviceRGB și sRGB

DeviceRGB — este cel mai răspândit spațiu de culoare implicit al Core Graphics. Utilizează gamutul de culoare al unui ecran LCD standard fără profilare ICC. La crearea contextului grafic UIView sau NSView, Core Graphics atribuie automat DeviceRGB ca spațiu de culoare implicit. sRGB — versiunea cu profilare ICC cu gamut și gamma fixe, recomandată pentru conținut web.

Display P3 — gamut larg de culoare

Display P3 — spațiu de culoare bazat pe standardul DCI-P3, utilizat în dispozitivele iOS moderne cu ecrane cu gamut larg de culoare. Acoperă cu aproximativ 25% mai multe culori vizibile decât sRGB, în special în zonele verde și roșu ale spectrului. Pentru lucrul cu Display P3 pe iOS se utilizează constanta kCGColorSpaceDisplayP3, disponibilă din iOS 9.3.

Crearea și gestionarea CGColor

CGColor se creează prin funcția CGColorCreate, care primește CGColorSpace și un tablou de componente de tip CGFloat. Numărul de componente depinde de modelul de culoare: pentru Gray — 1, pentru RGB — 3, pentru CMYK — 4. După creare, CGColor este un obiect imutabil (immutable) — componentele sale nu pot fi modificate, se poate doar crea o culoare nouă.

Core Graphics oferă, de asemenea, funcțiile CGColorCreateGenericRGB, CGColorCreateGenericGray și CGColorCreateGenericCMYK pentru crearea culorilor în spații de culoare standard (generic). Aceste funcții simplifică codul, eliminând necesitatea de a crea explicit CGColorSpace. În plus, în Quartz 2D sunt definite constantele culorilor de bază: kCGColorWhite, kCGColorBlack, kCGColorClear.

La crearea culorii, ordinea specificării componentelor este importantă — trebuie să corespundă strict ordinii canalelor definite de modelul spațiului de culoare. RGB: roșu (0.0–1.0), verde, albastru, alfa (0.0–1.0). Gray: luminozitate, alfa. CMYK: cyan, magenta, galben, negru, alfa. Încălcarea ordinii componentelor duce la afișarea incorectă a culorii fără eroare de compilare.

Canalul alfa și transparența

Canalul alfa — a patra componentă (sau a doua pentru Gray) care controlează transparența culorii. Valoarea 1.0 corespunde opacității complete, 0.0 — transparenței complete. Canalul alfa în CGColor este opțional: funcția CGColorGetAlpha returnează valoarea curentă a alfei, care implicit este 1.0 la crearea prin funcțiile de bază. La amestecarea culorilor, Core Graphics utilizează compoziția alfa conform regulii Porter-Duff Source Over.

Lucrul cu CGColorSpace

CGColorSpace se creează prin funcțiile factory ale Core Graphics: CGColorSpaceCreateDeviceRGB, CGColorSpaceCreateDeviceGray, CGColorSpaceCreateDeviceCMYK sau CGColorSpaceCreateWithName pentru spații denumite (sRGB, Display P3, Generic Gray). Obiectul CGColorSpace este imutabil și thread-safe — același obiect poate fi utilizat în mai multe contexte grafice.

Obținerea CGColorSpace de bază

Core Graphics oferă mai multe spații de culoare predefinite prin constante denumite: kCGColorSpaceSRGB, kCGColorSpaceDisplayP3, kCGColorSpaceGenericGrayGamma2_2. Aceste constante sunt transmise către CGColorSpaceCreateWithName. Pentru dispozitivele iOS cu gamut larg de culoare se recomandă utilizarea Display P3, deoarece sRGB poate să nu utilizeze pe deplin capacitățile ecranului.

Profilurile ICC și CGColorSpace personalizat

Profilurile ICC — sunt fișiere standardizate care descriu caracteristicile de culoare ale dispozitivului. Core Graphics permite crearea CGColorSpace pe baza oricărui profil ICC prin CGColorSpaceCreateWithICCProfile. Acest lucru este utilizat în aplicații profesionale pentru imprimare foto și prepress, unde este necesară conformitatea exactă cu o anumită imprimantă sau monitor.

Conversia între spațiile de culoare

Core Graphics realizează conversia între spațiile de culoare automat la desenare prin funcția CGContextSetFillColorWithColor sau CGContextSetStrokeColorWithColor. Dacă spațiul de culoare al contextului grafic diferă de spațiul de culoare al CGColor transmis, Quartz 2D efectuează conversia utilizând profilurile ICC ale ambelor spații.

Pentru conversia explicită a culorii se utilizează CGColorCreateCopyByMatchingToColorSpace — funcția creează un nou CGColor ale cărui componente sunt recalculate din spațiul sursă în cel țintă. Conform Apple Technical Note TN2313 (2024), la conversia din Display P3 în sRGB, culorile din afara gamutului sRGB sunt decupate, ceea ce duce la pierderea saturației. Acest lucru este deosebit de vizibil pe nuanțele de verde și roșu aprins.

ColorSync pe macOS asigură gestionarea sistematică a culorii la nivelul stivei grafice. Dacă aplicația nu specifică un spațiu de culoare explicit, Core Graphics utilizează spațiul ecranului obținut de la ColorSync. Acest lucru garantează că culorile vor arăta la fel pe diferite monitoare, chiar dacă acestea utilizează profiluri de culoare diferite.

Exemple de cod în Swift

Să examinăm exemple practice de creare și utilizare a CGColor și CGColorSpace într-o aplicație iOS. Codul este scris în Swift cu utilizarea funcțiilor Core Graphics.

Crearea CGColor cu diferite spații de culoare

Acest exemplu arată crearea culorii roșii în trei spații de culoare diferite. În ciuda acelorași componente RGB, culoarea va arăta diferit în funcție de gamutul de culoare al CGColorSpace.

import CoreGraphics

// Crearea culorii în DeviceRGB
let rgbSpace = CGColorSpaceCreateDeviceRGB()
let redColor = CGColorCreate(rgbSpace, [1.0, 0.0, 0.0, 1.0])

// Crearea culorii în Display P3
let p3Space = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3)
let p3RedColor = CGColorCreate(p3Space, [1.0, 0.0, 0.0, 1.0])

// Crearea culorii gri
let graySpace = CGColorSpaceCreateDeviceGray()
let grayColor = CGColorCreate(graySpace, [0.5, 1.0])

Conversia culorii între spațiile de culoare

În exemplu se realizează conversia culorii verde aprins din Display P3 în sRGB. La o astfel de conversie, culorile din afara gamutului sRGB vor fi adaptate, ceea ce poate modifica nuanța.

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

// Verde aprins în Display P3 (în afara gamutului sRGB)
let p3Green = CGColorCreate(p3Space, [0.0, 1.0, 0.0, 1.0])

// Conversia în sRGB
let srgbGreen = CGColorCreateCopyByMatchingToColorSpace(
    sRGBSpace, p3Green, kCGRenderingIntentDefault
)

Utilizarea CGColor în contextul grafic

Acest exemplu demonstrează desenarea unui cerc umplut utilizând CGColor într-un UIView personalizat. Metoda draw obține contextul grafic curent UIGraphicsGetCurrentContext, în care se setează culoarea de umplere.

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