CGColor e CGColorSpace: o que é, modelos de cor e como gerenciá-los

O que são CGColor e CGColorSpace?

CGColor é um objeto fundamental do Core Graphics que representa uma cor. A estrutura CGColor armazena valores numéricos de componentes de cor e uma referência ao CGColorSpace — o espaço de cor no qual esses componentes são interpretados. Sem estar vinculado a um espaço de cor, os valores numéricos dos componentes não têm significado: o valor (1.0, 0.0, 0.0) em RGB é vermelho, mas em CMYK é ciano.

CGColorSpace é um objeto que define um modelo de cor e o intervalo de valores representáveis (gamut). O espaço de cor estabelece as regras pelas quais os componentes numéricos se transformam em uma cor visível em um dispositivo de saída específico. O Core Graphics suporta tanto espaços padrão com perfil ICC quanto espaços personalizados criados via CGColorSpace com tabelas de transformação personalizadas.

A arquitetura que separa a cor do espaço de cor é uma característica chave do Core Graphics que o diferencia de APIs onde a cor é armazenada como um simples conjunto de números. Essa abordagem permite que o Core Graphics realize gerenciamento de cor independente de dispositivo: o mesmo objeto CGColor pode ser exibido corretamente em diferentes telas graças à conversão automática de componentes através do perfil CGColorSpace.

Como as cores funcionam no Core Graphics

Core Graphics implementa a cor através de um modelo baseado em perfis ICC (International Color Consortium). Cada CGColorSpace contém uma referência a um perfil ICC — uma descrição padronizada de como os componentes de cor são convertidos para CIE XYZ — um espaço de cor independente de dispositivo. Isso permite que o Core Graphics realize compensação colorimétrica automática entre diferentes telas.

Ciclo de vida de um objeto CGColor

Ao criar um CGColor através da função CGColorCreate, os componentes são capturados do array passado e vinculados ao CGColorSpace especificado. O Core Graphics copia os componentes para uma representação interna e cria uma associação com o espaço de cor. Depois disso, a cor está pronta para uso em qualquer operação gráfica — preenchimento, traçado, gradiente, sombra.

Gerenciamento de cor via ColorSync

No macOS, o gerenciamento de cor é tratado através do framework ColorSync, integrado ao Core Graphics. O ColorSync rastreia a calibração da tela e converte automaticamente os componentes do espaço de cor de origem para o espaço do dispositivo de destino. No iOS, o gerenciamento de cor é implementado através do Quartz Core com suporte a ampla gama de cores (Display P3), a partir do iPhone 7.

Modelos de cor básicos no CGColorSpace

CGColorSpace suporta quatro modelos de cor básicos: RGB (DeviceRGB, sRGB, Display P3), Gray (DeviceGray), CMYK (DeviceCMYK) e Lab. Cada modelo define o número e o significado dos componentes de cor. RGB usa três canais — vermelho, verde, azul; Gray usa um canal de luminância; CMYK usa quatro canais para impressão; Lab usa três canais: luminância e dois componentes de diferença de cor.

DeviceRGB e sRGB

DeviceRGB é o espaço de cor padrão mais comum do Core Graphics. Ele usa a gama de cores de um display LCD padrão sem perfil ICC. Ao criar um contexto gráfico UIView ou NSView, o Core Graphics atribui automaticamente o DeviceRGB como espaço de cor padrão. sRGB é uma versão com perfil ICC com gama e gamma fixos, recomendada para conteúdo web.

Display P3 — Ampla gama de cores

Display P3 é um espaço de cor baseado no padrão DCI-P3, usado em dispositivos iOS modernos com telas de ampla gama cromática. Ele cobre aproximadamente 25% mais cores visíveis que o sRGB, especialmente nas áreas verde e vermelha do espectro. Para trabalhar com Display P3 no iOS, use a constante kCGColorSpaceDisplayP3, disponível desde o iOS 9.3.

Criação e gerenciamento de CGColor

CGColor é criado através da função CGColorCreate, que recebe um CGColorSpace e um array de componentes CGFloat. O número de componentes depende do modelo de cor: 1 para Gray, 3 para RGB, 4 para CMYK. Uma vez criado, o CGColor é um objeto imutável — você não pode alterar seus componentes, apenas criar uma nova cor.

O Core Graphics também fornece as funções CGColorCreateGenericRGB, CGColorCreateGenericGray e CGColorCreateGenericCMYK para criar cores em espaços de cor padrão (genéricos). Essas funções simplificam o código eliminando a necessidade de criar explicitamente um CGColorSpace. Além disso, o Quartz 2D define constantes para cores básicas: kCGColorWhite, kCGColorBlack, kCGColorClear.

Ao criar uma cor, a ordem de especificação dos componentes é importante — deve corresponder estritamente à ordem dos canais definida pelo modelo de espaço de cor. RGB: vermelho (0.0–1.0), verde, azul, alfa (0.0–1.0). Gray: luminância, alfa. CMYK: ciano, magenta, amarelo, preto, alfa. Violar a ordem dos componentes leva a uma exibição incorreta da cor sem erro de compilação.

Canal alfa e transparência

O canal alfa é o quarto componente (ou segundo para Gray) que controla a transparência da cor. Um valor de 1.0 corresponde a opacidade total, 0.0 a transparência total. O canal alfa no CGColor é opcional: a função CGColorGetAlpha retorna o valor alfa atual, que por padrão é 1.0 quando criado através de funções básicas. Ao misturar cores, o Core Graphics usa composição alfa de acordo com a regra Porter-Duff Source Over.

Trabalhando com CGColorSpace

CGColorSpace é criado através das funções de fábrica do Core Graphics: CGColorSpaceCreateDeviceRGB, CGColorSpaceCreateDeviceGray, CGColorSpaceCreateDeviceCMYK ou CGColorSpaceCreateWithName para espaços nomeados (sRGB, Display P3, Generic Gray). O objeto CGColorSpace é imutável e seguro para threads — o mesmo objeto pode ser usado em múltiplos contextos gráficos.

Obtendo CGColorSpace básicos

Core Graphics fornece vários espaços de cor predefinidos através de constantes nomeadas: kCGColorSpaceSRGB, kCGColorSpaceDisplayP3, kCGColorSpaceGenericGrayGamma2_2. Essas constantes são passadas para CGColorSpaceCreateWithName. Para dispositivos iOS com ampla gama de cores, recomenda-se o Display P3, pois o sRGB pode não utilizar totalmente as capacidades da tela.

Perfis ICC e CGColorSpace personalizados

Perfis ICC são arquivos padronizados que descrevem as características cromáticas de um dispositivo. O Core Graphics permite criar um CGColorSpace baseado em um perfil ICC arbitrário através de CGColorSpaceCreateWithICCProfile. Isso é usado em aplicações profissionais para impressão de fotos e pré-impressão onde é necessária correspondência precisa com uma impressora ou monitor específicos.

Conversão entre espaços de cor

Core Graphics realiza a conversão entre espaços de cor automaticamente durante a renderização através das funções CGContextSetFillColorWithColor ou CGContextSetStrokeColorWithColor. Se o espaço de cor do contexto gráfico diferir do espaço de cor do CGColor passado, o Quartz 2D realiza a conversão usando os perfis ICC de ambos os espaços.

Para conversão explícita de cor, use CGColorCreateCopyByMatchingToColorSpace — uma função que cria um novo CGColor cujos componentes são recalculados do espaço de origem para o espaço de destino. De acordo com a Apple Technical Note TN2313 (2024), ao converter de Display P3 para sRGB, as cores fora da gama sRGB são recortadas, resultando em perda de saturação. Isso é especialmente perceptível em tons verdes e vermelhos brilhantes.

ColorSync no macOS fornece gerenciamento de cor em nível de sistema na pilha gráfica. Se uma aplicação não especificar um espaço de cor explícito, o Core Graphics usa o espaço da tela obtido do ColorSync. Isso garante que as cores tenham a mesma aparência em monitores diferentes, mesmo que usem perfis de cor diferentes.

Exemplos de código Swift

Vejamos exemplos práticos de criação e uso de CGColor e CGColorSpace em uma aplicação iOS. O código é escrito em Swift usando funções do Core Graphics.

Criação de CGColor com diferentes espaços de cor

Este exemplo mostra a criação de uma cor vermelha em três espaços de cor diferentes. Apesar de ter os mesmos componentes RGB, a cor terá aparência diferente dependendo da gama do CGColorSpace.

import CoreGraphics

// Criando cor em DeviceRGB
let rgbSpace = CGColorSpaceCreateDeviceRGB()
let redColor = CGColorCreate(rgbSpace, [1.0, 0.0, 0.0, 1.0])

// Criando cor em Display P3
let p3Space = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3)
let p3RedColor = CGColorCreate(p3Space, [1.0, 0.0, 0.0, 1.0])

// Criando cor cinza
let graySpace = CGColorSpaceCreateDeviceGray()
let grayColor = CGColorCreate(graySpace, [0.5, 1.0])

Conversão de cor entre espaços de cor

Este exemplo converte uma cor verde brilhante de Display P3 para sRGB. Durante essa conversão, as cores fora da gama sRGB serão adaptadas, o que pode alterar o tom.

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

// Verde brilhante em Display P3 (fora da gama sRGB)
let p3Green = CGColorCreate(p3Space, [0.0, 1.0, 0.0, 1.0])

// Convertendo para sRGB
let srgbGreen = CGColorCreateCopyByMatchingToColorSpace(
    sRGBSpace, p3Green, kCGRenderingIntentDefault
)

Usando CGColor em um contexto gráfico

Este exemplo demonstra o desenho de um círculo preenchido usando CGColor em um UIView personalizado. O método draw obtém o contexto gráfico atual UIGraphicsGetCurrentContext, no qual a cor de preenchimento é definida.

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