CoreImage: filtros e processamento de imagens

O que é CoreImage

CoreImage é um framework da Apple para processamento de imagens raster e vídeo, introduzido pela primeira vez no macOS 10.4 Tiger e portado para o iOS 5.0. Ao contrário do Core Graphics ou UIKit, o CoreImage funciona no nível de shaders de pixel, usando a GPU para cálculos paralelos. Isso permite aplicar efeitos complexos — desfoque, correção de cor, morfismo — a imagens de resolução de megapixels em milissegundos.

A arquitetura do CoreImage é construída sobre o conceito de avaliação preguiçosa (lazy evaluation): o CIFilter não realiza processamento até a renderização no CIContext. O desenvolvedor constrói uma cadeia de vários CIFilters, conectando a saída de um filtro à entrada de outro, e apenas a chamada render inicia o pipeline completo da GPU. Isso minimiza o número de passes através da placa gráfica e mantém o desempenho.

O CoreImage suporta ampla gama de cores (P3, sRGB, sRGB linear), imagens HDR e trabalho com formatos de pixel de 16 e 32 bits. Em dispositivos com Neural Engine, o CoreImage pode combinar shaders de GPU com Core ML para processamento inteligente — por exemplo, correção automática de cor baseada em aprendizado de máquina, como implementado no aplicativo Fotos no iOS 17.

Arquitetura do CoreImage: CIImage, CIFilter, CIContext

Três classes principais formam o núcleo do CoreImage: CIImage (dados), CIFilter (operação) e CIContext (ambiente de execução). Cada classe é responsável por sua própria fase do pipeline e não mistura responsabilidades.

CIImage — Fonte imutável

CIImage é um objeto leve que descreve uma imagem mas não contém dados de pixel diretamente. Pode ser criado a partir de UIImage, CGImage, textura Metal, textura GL ou um arquivo em disco. CIImage é imutável — qualquer aplicação de filtro cria um novo CIImage sem modificar o original. Isso permite construir cadeias de transformação sem copiar dados entre etapas.

Uma característica importante: CIImage não está vinculado à resolução da tela ou ao espaço de cor até a renderização. O mesmo CIImage pode ser renderizado em um UIImage para tela e em um arquivo TIFF para impressão com parâmetros diferentes — o CoreImage adapta automaticamente o processamento ao contexto de destino.

CIFilter — Operação de processamento

CIFilter é a classe principal para aplicar efeitos. Cada CIFilter é um programa shader com parâmetros de entrada (inputImage, inputIntensity, inputRadius, etc.) e uma imagem de saída. A Apple fornece mais de 200 CIFilters integrados, agrupados por categorias: CICategoryColorEffect (correção de cor), CICategoryBlur (desfoque), CICategoryStylize (estilização), CICategoryGeometryAdjust (transformações geométricas).

Para criar um CIFilter personalizado, o desenvolvedor escreve um shader Metal (CIKernel) — um shader de fragmentos na Metal Shading Language que processa cada pixel independentemente. Após a compilação, o shader é registrado como uma subclasse de CIFilter e pode ser usado em cadeias junto com os filtros integrados da Apple.

CIContext — Ambiente de renderização

CIContext é um objeto pesado que gerencia alocação de recursos de GPU, compilação de shaders e buffering. Criar um CIContext é uma operação cara, então a Apple recomenda criá-lo uma vez durante todo o ciclo de vida da aplicação e reutilizá-lo. O contexto está vinculado a uma GPU específica (Metal, OpenGL) ou CPU e determina o espaço de cor da imagem de saída.

CIFilter: filtros integrados e shaders Metal personalizados

A biblioteca CIFilter está em constante expansão: o iOS 17 adicionou novos filtros para processamento HDR e aprendizado de máquina. Todos os filtros integrados estão documentados na Documentação para Desenvolvedores da Apple e podem ser pesquisados por categorias ou nomes. Para descobrir os filtros disponíveis no dispositivo, use CIFilter.filterNames(inCategory:).

Cadeia de vários filtros

A principal capacidade do CoreImage é compor vários CIFilters em uma cadeia. A saída de um filtro é alimentada na entrada de outro através do parâmetro inputImage. O CoreImage otimiza a cadeia no estágio de renderização: filtros adjacentes que trabalham no mesmo espaço de cor são combinados em um único passe de GPU (kernel fusion). Isso proporciona um ganho de desempenho sem intervenção do desenvolvedor.

Filtros personalizados via CIKernel

Para criar um efeito personalizado, o desenvolvedor escreve uma função Metal com a anotação [[kernel]]. A função recebe coordenadas de pixel e retorna uma cor. O CoreImage passa o shader para a GPU, onde é executado em paralelo para todos os pixels da imagem. Filtros personalizados são especialmente úteis para efeitos visuais únicos: sépia com curva não linear, desfoque de dispersão ou simulação de granulado de filme.

#include <CoreImage/CoreImage.h>

[[kernel]] float4 customFilter(sample_t s, float intensity) {
    float4 result;
    result.rgb = s.rgb * (1.0 - intensity) + s.r * intensity;
    result.a = s.a;
    return result;
}

Desempenho e cache

CoreImage gerencia automaticamente o cache de resultados intermediários. Se a mesma cadeia de filtros for aplicada a diferentes imagens, o CoreImage pode reutilizar shaders compilados. Para máximo desempenho, evite criar um CIContext para cada quadro — use um único contexto e redefina os parâmetros de entrada do filtro.

CIDetector: detecção de rostos, texto e objetos

CIDetector é um subsistema do CoreImage para detectar objetos semânticos em uma imagem sem usar Vision ou Core ML. O CIDetector suporta quatro tipos de detecção: rostos (CIDetectorTypeFace), texto (CIDetectorTypeText), QR codes (CIDetectorTypeQRCode) e retângulos (CIDetectorTypeRectangle). O detector funciona na CPU com otimização para instruções NEON, garantindo velocidade estável em dispositivos sem uma GPU poderosa.

Detecção de rostos

O detector de rostos CIDetectorTypeFace retorna um array de CIFaceFeature com coordenadas dos limites do rosto, posição dos olhos e boca. Desde o iOS 12, o CIDetector também detecta sorrisos (hasSmile) e posição do olho esquerdo/direito (leftEyeClosed, rightEyeClosed). A precisão da detecção é suficiente para a maioria das aplicações AR e de fotos, mas para cenários críticos a Apple recomenda o Vision.framework.

Detecção de retângulos

CIDetectorTypeRectangle encontra áreas retangulares em uma imagem — documentos, cartões de visita, telas de dispositivos. O detector retorna CIRectangleFeature com quatro pontos que formam o contorno do retângulo. De acordo com a WWDC 2024, o detector de retângulos usa a mesma arquitetura de rede neural que o Vision, mas com menor consumo de memória. Isso o torna preferível para processamento de fluxo de quadros em tempo real, por exemplo, em aplicativos de digitalização de documentos.

Exemplos de código: filtros e detecção em Swift

Exemplos práticos ajudarão a consolidar a compreensão do CoreImage. Vejamos dois cenários típicos: aplicar um filtro de cor a uma foto e detecção de rostos com desenho de caixa delimitadora.

Aplicar sépia a uma imagem

Um exemplo básico do filtro CISepiaTone, que converte uma imagem colorida para tons de sépia. O filtro aceita o parâmetro inputIntensity de 0 (original) a 1 (efeito máximo). Observe a avaliação preguiçosa: o CIImage retornado por filter.outputImage não contém pixels — a renderização só acontece quando context.createCGImage é chamado.

import CoreImage

guard let inputImage = CIImage(image: uiImage) else { return }
let filter = CIFilter(name: "CISepiaTone")
filter?.setValue(inputImage, forKey: kCIInputImageKey)
filter?.setValue(0.8, forKey: kCIInputIntensityKey)

let context = CIContext()
let outputImage = filter?.outputImage
let cgImage = context.createCGImage(outputImage!, from: inputImage.extent)
let resultImage = UIImage(cgImage: cgImage!)

Detecção de rostos com desenho de caixa delimitadora

O exemplo a seguir usa CIDetector para encontrar rostos em uma imagem e desenhar um retângulo ao redor de cada rosto detectado. O CIFaceFeature contém coordenadas no sistema de coordenadas da imagem (origem no canto inferior esquerdo), portanto, ao desenhar no UIKit, é necessária uma transformação de coordenadas através de transformação afim.

let detector = CIDetector(
    ofType: CIDetectorTypeFace,
    context: context,
    options: [CIDetectorAccuracy: CIDetectorAccuracyHigh]
)
let features = detector?.features(in: inputImage) as? [CIFaceFeature]

for face in features ?? [] {
    print("Face bounds: \(face.bounds)")
    if face.hasSmile {
        print("A pessoa está sorrindo")
    }
}

Composição de vários efeitos

O exemplo final demonstra uma cadeia de três filtros: correção de cor, vinheta e sobreposição de textura. Observe que o outputImage do primeiro filtro é passado como inputImage para o segundo — sem renderização intermediária. Quando createCGImage é chamado, o CoreImage combina todas as três operações em um único passe de GPU.

let colorFilter = CIFilter(name: "CIColorControls")
colorFilter?.setValue(inputImage, forKey: kCIInputImageKey)
colorFilter?.setValues([
    kCIInputBrightnessKey: 0.1,
    kCIInputContrastKey: 1.2
])

let vignetteFilter = CIFilter(name: "CIVignette")
vignetteFilter?.setValue(colorFilter?.outputImage, forKey: kCIInputImageKey)
vignetteFilter?.setValue(2.0, forKey: "inputRadius")

let finalImage = vignetteFilter?.outputImage
let result = context.createCGImage(finalImage!, from: inputImage.extent)