CoreImage: wat is het, filters en werken met afbeeldingen

Wat is CoreImage

CoreImage is een Apple-framework voor het verwerken van rasterafbeeldingen en video, voor het eerst geïntroduceerd in macOS 10.4 Tiger en overgezet naar iOS 5.0. In tegenstelling tot Core Graphics of UIKit werkt CoreImage op het niveau van pixelshaders, waarbij de GPU wordt gebruikt voor parallelle berekeningen. Dit maakt het mogelijk om complexe effecten — vervaging, kleurcorrectie, morphing — toe te passen op afbeeldingen met megapixelresolutie in milliseconden.

De architectuur van CoreImage is gebaseerd op het concept van luie evaluatie (lazy evaluation): CIFilter voert geen verwerking uit tot het moment van renderen in CIContext. De ontwikkelaar bouwt een keten van meerdere CIFilters, waarbij de uitvoer van de ene filter wordt verbonden met de invoer van de andere, en alleen de aanroep render start de volledige GPU-pijplijn. Dit minimaliseert het aantal doorgangen door de videokaart en behoudt de prestaties.

CoreImage ondersteunt brede kleurengammut (P3, sRGB, lineair sRGB), HDR-afbeeldingen en werken met 16-bits en 32-bits pixelformaten. Op apparaten met Neural Engine kan CoreImage GPU-shaders combineren met Core ML voor intelligente verwerking — bijvoorbeeld automatische kleurcorrectie op basis van machine learning, zoals geïmplementeerd in de Foto-app op iOS 17.

CoreImage-architectuur: CIImage, CIFilter, CIContext

Drie hoofdklassen vormen de kern van CoreImage: CIImage (gegevens), CIFilter (bewerking) en CIContext (uitvoeringsomgeving). Elke klasse is verantwoordelijk voor zijn eigen fase in de pijplijn en mengt verantwoordelijkheden niet.

CIImage — onveranderlijke bron

CIImage is een lichtgewicht object dat de afbeelding beschrijft, maar geen directe pixelgegevens bevat. Het kan worden gemaakt van UIImage, CGImage, Metal-textuur, GL-textuur of een bestand op schijf. CIImage is onveranderlijk — elke toepassing van een filter creëert een nieuwe CIImage zonder het origineel te wijzigen. Dit maakt het mogelijk om transformatieketens te bouwen zonder gegevens tussen stappen te kopiëren.

Belangrijk kenmerk: CIImage is niet gebonden aan de schermresolutie of kleurruimte tot het moment van renderen. Dezelfde CIImage kan worden gerenderd naar UIImage voor het scherm en naar TIFF-bestand voor afdrukken met verschillende parameters — CoreImage past de verwerking automatisch aan de doelcontext aan.

CIFilter — verwerkingsbewerking

CIFilter is de hoofdklasse voor het toepassen van effecten. Elke CIFilter vertegenwoordigt een shaderprogramma met invoerparameters (inputImage, inputIntensity, inputRadius enz.) en een uitvoerafbeelding. Apple levert meer dan 200 ingebouwde CIFilters, gegroepeerd in categorieën: CICategoryColorEffect (kleurcorrectie), CICategoryBlur (vervaging), CICategoryStylize (stylisering), CICategoryGeometryAdjust (geometrische transformaties).

Om een aangepaste CIFilter te maken, schrijft de ontwikkelaar een Metal-shader (CIKernel) — een fragmentshader in de taal Metal Shading Language die elke pixel onafhankelijk verwerkt. Na compilatie wordt de shader geregistreerd als een subklasse van CIFilter en kan worden gebruikt in ketens samen met de ingebouwde Apple-filters.

CIContext — renderomgeving

CIContext is een zwaar object dat de toewijzing van GPU-bronnen, shadercompilatie en buffering beheert. Het aanmaken van CIContext is een dure operatie, dus Apple raadt aan om het eenmalig te maken voor de hele levenscyclus van de app en het te hergebruiken. De context is gekoppeld aan een specifieke GPU (Metal, OpenGL) of CPU en bepaalt de kleurruimte van de uitvoerafbeelding.

CIFilter: ingebouwde filters en aangepaste Metal-shaders

De CIFilter-bibliotheek breidt zich voortdurend uit: iOS 17 heeft nieuwe filters toegevoegd voor HDR-verwerking en machine learning. Alle ingebouwde filters zijn gedocumenteerd in Apple Developer Documentation en kunnen worden doorzocht op categorie of naam. Gebruik CIFilter.filterNames(inCategory:) om beschikbare filters op het apparaat te detecteren.

Keten van meerdere filters

De belangrijkste mogelijkheid van CoreImage — het samenstellen van meerdere CIFilters in een keten. De uitvoer van de ene filter wordt via de parameter inputImage aan de invoer van de volgende geleverd. CoreImage optimaliseert de keten in de renderfase: aangrenzende filters die in dezelfde kleurruimte werken, worden gecombineerd in één GPU-doorgang (kernel fusion). Dit levert een prestatieverbetering op zonder tussenkomst van de ontwikkelaar.

Aangepaste filters via CIKernel

Om een eigen effect te creëren, schrijft de ontwikkelaar een Metal-functie met de annotatie [[kernel]]. De functie ontvangt pixelcoördinaten en retourneert een kleur. CoreImage stuurt de shader naar de GPU, waar deze parallel wordt uitgevoerd voor alle pixels van de afbeelding. Aangepaste filters zijn vooral nuttig voor unieke visuele effecten: sepia met niet-lineaire curve, dispersievervaging of imitatie van filmkorrel.

#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;
}

Prestaties en caching

CoreImage beheert automatisch de cache van tussenresultaten. Als dezelfde filterketen wordt toegepast op verschillende afbeeldingen, kan CoreImage gecompileerde shaders hergebruiken. Voor maximale prestaties, vermijd het aanmaken van CIContext voor elk frame — gebruik één context en stel de invoerparameters van de filter opnieuw in.

CIDetector: gezichts-, tekst- en objectdetectie

CIDetector is het subsysteem van CoreImage voor het detecteren van semantische objecten in een afbeelding zonder gebruik van Vision of Core ML. CIDetector ondersteunt vier soorten detectie: gezichten (CIDetectorTypeFace), tekst (CIDetectorTypeText), QR-codes (CIDetectorTypeQRCode) en rechthoeken (CIDetectorTypeRectangle). De detector werkt op de CPU met optimalisatie voor NEON-instructies, wat een stabiele snelheid garandeert op apparaten zonder krachtige GPU.

Gezichtsdetectie

De gezichtsdetector CIDetectorTypeFace retourneert een array van CIFaceFeature met coördinaten van gezichtsgrenzen, oog- en mondposities. Vanaf iOS 12 bepaalt CIDetector ook de glimlach (hasSmile) en de positie van het linker/rechteroog (leftEyeClosed, rightEyeClosed). De detectienauwkeurigheid is voldoende voor de meeste AR- en foto-applicaties, maar voor kritieke scenarioën raadt Apple Vision.framework aan.

Rechthoekdetectie

CIDetectorTypeRectangle vindt rechthoekige gebieden in de afbeelding — documenten, visitekaartjes, apparaatschermen. De detector retourneert CIRectangleFeature met vier punten die de contour van de rechthoek vormen. Volgens WWDC 2024 gebruikt de rechthoekdetector dezelfde neurale netwerkarchitectuur als Vision, maar met lager geheugengebruik. Dit maakt hem preferent voor real-time verwerking van framestromen, bijvoorbeeld in documentscanner-apps.

Codevoorbeelden: filters en detectie in Swift

Praktische voorbeelden helpen het begrip van CoreImage te verstevigen. Laten we twee typische scenario’s bekijken: het toepassen van een kleurenfilter op een foto en gezichtsdetectie met het tekenen van een kader.

Sepia toepassen op een afbeelding

Basisvoorbeeld van het CISepiaTone-filter, dat een kleurenafbeelding omzet in sepiatinten. Het filter accepteert de parameter inputIntensity van 0 (origineel) tot 1 (maximaal effect). Let op de luie evaluatie: de CIImage die wordt geretourneerd door filter.outputImage bevat geen pixels — renderen vindt pas plaats bij de aanroep context.createCGImage.

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

Gezichtsdetectie met kadertekening

Het volgende voorbeeld gebruikt CIDetector om gezichten in een afbeelding te vinden en een rechthoek rond elk gevonden gezicht te tekenen. CIFaceFeature bevat coördinaten in het beeldcoördinatenstelsel (oorsprong in de linkerbenedenhoek), dus bij het tekenen op UIKit is transformatie van coördinaten via affiene transform vereist.

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("Persoon glimlacht")
    }
}

Compositie van meerdere effecten

Het laatste voorbeeld toont een keten van drie filters: kleurcorrectie, vignettering en textuuraanbrenging. Let op dat outputImage van de eerste filter wordt doorgegeven als inputImage aan de tweede — zonder tussenliggende rendering. Bij de aanroep createCGImage combineert CoreImage alle drie bewerkingen in één GPU-doorgang.

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)