Face Detection i appar: vad det är, metoder och bibliotek

Vad är Face Detection: principer och algoritmer

Face Detection — en datorseendeuppgift för att bestämma förekomsten och placeringen av mänskliga ansikten i en bild. Algoritmen returnerar en bounding box (rektangel runt ansiktet) och en confidence score (sannolikheten att det är ett ansikte). Moderna algoritmer returnerar också facial landmarks — viktiga punkter (ögon, ögonbryn, näsa, mun, ansiktskontur). Face Detection är den första fasen för många ML-uppgifter: personigenkänning, AR-filter, uppmärksamhetsanalys.

Algoritmers historia började med Viola-Jones (2001) — kaskad av Haar-liknande egenskaper på CPU. Under 2010-talet dominerade HOG + SVM (Histogram of Oriented Gradients). Sedan 2016 är alla moderna algoritmer baserade på konvolutionella neuronnätverk (CNN): MTCNN, RetinaFace, SSH, MobileNet-SSD, YOLO-Face. CNN-algoritmer på GPU ger 95–99% noggrannhet jämfört med 85–90% för klassiska metoder. Enligt WiderFace benchmark (2025) visar RetinaFace en mAP på 96.3% på den svåraste delmängden.

MTCNN (Multi-Task Cascaded CNN) — en klassisk trestegsdetektor: P-Net (Proposal Network) hittar kandidater, R-Net (Refine Network) filtrerar, O-Net (Output Network) förfinar bounding box och levererar landmarks. MTCNN fungerar på CPU med en hastighet på 30–50 ms per bildruta vid upplösningen 640x480. För mobila enheter erbjuder MTCNN en optimal balans mellan hastighet och noggrannhet utan GPU.

Real-time Face Detection kräver 30+ FPS för video. Detta är möjligt på moderna smartphones tack vare NPU (Neural Processing Unit) — Qualcomm Hexagon, Apple Neural Engine, MediaTek APU. NPU utför detektion på 2–5 ms med en energiförbrukning på 50–100 mW, medan GPU förbrukar 500–2000 mW. För kontinuerlig detektion (kamera alltid på) är NPU det enda praktiska alternativet utan överhettning av enheten.

ML Kit Face Detection på Android och iOS

ML Kit Face Detection — den mest populära SDK för ansiktsdetektion på mobila enheter. ML Kit erbjuder två lägen: contour mode (468 konturpunkter i ansiktet för exakt placering av masker) och classification mode (bestämning av känslor: leende, öppna ögon, öppen mun). Lägen kombineras i FaceDetectorOptions. ML Kit använder Googles neuronnätverk MobileNetV2-SSD med optimering via NNAPI/GPU Delegate.

Konfiguration av ML Kit Face Detection: setPerformanceMode(FACE_DETECTION_FAST / ACCURATE), setLandmarkMode (viktiga punkter), setContourMode (konturpunkter), setClassificationMode (känslor). För maximal hastighet använd FAST + LANDMARKS_ONLY + utan kontur. För AR-filter — ACCURATE + ALL_CONTOURS. Enligt Google (2025) ger FAST-läget 98% noggrannhet vid 5 ms, ACCURATE — 99% vid 15 ms.

// ML Kit Face Detection med konturer
val options = FaceDetectorOptions.Builder()
    .setContourMode(FaceDetectorOptions.ContourMode.ALL)
    .setClassificationMode(FaceDetectorOptions.ClassificationMode.ALL)
    .setPerformanceMode(FaceDetectorOptions.PerformanceMode.FAST)
    .enableTracking()
    .build()
val detector = FaceDetection.getClient(options)

detector.process(inputImage)
    .addOnSuccessListener { faces ->
        faces.forEach { face ->
            val trackingId = face.trackingId
            val smile = face.smilingProbability
            val leftEyeOpen = face.leftEyeOpenProbability
        }
    }

Face Tracking i ML Kit — en unik funktion för videoströmmar. Varje upptäckt ansikte tilldelas ett tracking ID (heltal) som bevaras mellan bildrutor. Detta gör att AR-objekt kan kopplas till ett specifikt ansikte utan omdetektering. Spåraren använder Optical Flow och behåller ID även vid partiell täckning av ansiktet. Tracking ID återställs när ansiktet lämnar bildrutan i mer än 1 sekund.

Apple Vision Framework: VNDetectFaceRectanglesRequest

Apple Vision Framework — det ursprungliga iOS-ramverket för Face Detection, som fungerar via Core ML på Apple Neural Engine. Vision tillhandahåller VNDetectFaceRectanglesRequest (endast bounding box) och VNDetectFaceLandmarksRequest (med konturpunkter). Vision Framework är inbyggt i iOS sedan iOS 11 och kräver inga extra SDK:er — det är en del av Foundation.

Fördelar med Vision Framework: noll beroende av tredjepartsbibliotek, arbete via Apple Neural Engine (ANE) på A12+-chips, automatisk bildorienteringshantering via exifOrientation, stöd för CIDetectorAccuracy för hastighets-/noggrannhetsjustering. Vision returnerar VNFaceObservation med bounding box (normaliserade koordinater 0..1) och landmarks (VNFaceLandmarkRegion2D).

Vision vs ML Kit på iOS: Vision är snabbare på äldre enheter (A12–A15) eftersom det använder Apples ursprungliga neurala motorer. ML Kit använder Google-modeller och kan vara mer noggrann vid svåra vinklar (profil, kraftig lutning). För enkel detektion (kamera, foto) — Vision. För AR-filter och konturmasker — ML Kit (468 punkter vs 76 punkter i Vision).

import Vision

let request = VNDetectFaceRectanglesRequest { request, error in
    guard let observations = request.results as? [VNFaceObservation] else { return }
    for face in observations {
        let rect = face.boundingBox // normaliserad 0..1
        let confidence = face.confidence
    }
}

let handler = VNImageRequestHandler(
    cgImage: cgImage, orientation: .up, options: [:]
)
try handler.perform([request])

VNDetectFaceLandmarksRequest — den utökade versionen för viktiga punkter. Returnerar VNFaceLandmarkRegion2D för varje grupp av punkter: leftEye, rightEye, nose, faceContour, innerLips, outerLips. Varje grupp är en array av CGPoint (normaliserad). Vision returnerar inte 468 punkter som ML Kit — endast 76 viktiga punkter. För en exakt ansiktsmask är ML Kit att föredra; för grundläggande — Vision.

OpenCV Haar Cascade: klassisk metod

OpenCV Haar Cascade — den klassiska Face Detection-algoritmen baserad på en kaskad av Haar-liknande egenskaper (Viola-Jones, 2001). Trots sin ålder används Haar Cascade fortfarande i projekt med begränsade resurser: Raspberry Pi, IoT-enheter, inbyggda system. Algoritmen kräver inte GPU eller NPU — den fungerar på vilken CPU som helst med en hastighet på 5–15 ms per bildruta vid VGA-upplösning.

LBP Cascade (Local Binary Patterns) — ett alternativ till Haar Cascade i OpenCV. LBP är snabbare (2–5 ms) och mindre känsligt för belysning, men ger fler falskt positiva resultat. Haar är noggrannare (85–90% vs 80–85% för LBP), men känsligt för blänk och skuggor. För mobilappar är OpenCV Face Detection sämre i noggrannhet jämfört med neuronnätsmetoder, men vinner i kompatibilitet — fungerar på vilken enhet som helst.

// OpenCV Face Detection via CascadeClassifier
val cascadeFile = File(context.filesDir, "haarcascade_frontalface_default.xml")
val faceDetector = CascadeClassifier(cascadeFile.absolutePath)

val gray = Mat()
Imgproc.cvtColor(colorFrame, gray, Imgproc.COLOR_RGBA2GRAY)
val faces = MatOfRect()
faceDetector.detectMultiScale(gray, faces)

faces.toList().forEach { rect ->
    // rect = ansiktsbounding box
}

Nackdelar med OpenCV: hög falskt positiv frekvens (upp till 15%), dålig prestanda vid profilvinklar (>30° — noggrannhet minskar till 50%), inga landmarks utan ytterligare modell, ingen spårning mellan bildrutor. För moderna mobilappar är OpenCV Face Detection en reserv för enheter utan Google Play Services (Huawei, Amazon Fire). För huvudsakliga scenarier — ML Kit eller Vision.

Face Detection vs Face Recognition: skillnad

Face Detection — bestämning av förekomsten och positionen av ett ansikte i bilden. Resultat: bounding box och viktiga punkter. Face Recognition — identifiering av en person baserat på ansiktet: bestämning av vem ansiktet tillhör. Face Recognition använder embeddings (vektor av tal som representerar ansiktet) och jämför dem med en databas av kända ansikten. Face Detection är den obligatoriska första fasen för Face Recognition.

Face Recognition-teknologier: FaceNet (Google, 2015) — triplet loss för inlärning av embeddings med storlek 128–512 float-värden, ArcFace (2019) — additive angular margin loss, bästa noggrannhet (99.83% på LFW). För mobilappar kräver Face Recognition en anpassad TFLite-modell — ML Kit tillhandahåller inte ett färdigt API för personidentifiering (endast detektion).

Integritet på mobila enheter: Face Detection är säker — lagrar inte data om användaren. Face Recognition kräver lagring av embeddings eller foton för jämförelse. Apple kräver uttryckligt samtycke från användaren för Face Recognition och förbjuder användning för reklam. Google ML Kit inkluderar medvetet inte Face Recognition för att undvika integritetsrisker. För detektion utan identifiering — inga begränsningar.

Face Liveness Detection — ytterligare kontroll att ansiktet är verkligt (inte foto/video). Använder ögonrörelseanalys (blink detection), mikro-mimik, djupkarta (3D-kamera). Liveness Detection är obligatorisk för bank- och betalningsappar. ML Kit har ingen inbyggd liveness-funktion — använd en anpassad modell eller Google Play Integrity API för verifiering.

Tillämpning av Face Detection i mobilappar

AR-filter och masker — den mest populära tillämpningen av Face Detection. Baserat på ansiktets konturpunkter (468 punkter) appliceras 3D-masker, hattar, glasögon, mustascher. ML Kit Face Detection + SceneKit (iOS) eller Filament (Android) skapar en real-time AR-upplevelse. Snapchat och Instagram använder egna detektorer baserade på MobileNet + MTCNN. För anpassade AR-filter räcker ML Kit och en 3D-motor.

Fotoredigerare och retusch — Face Detection bestämmer ansiktsområdet för automatisk korrigering: utjämning av hudfärg, borttagning av defekter, förbättring av ögon och tänder. OpenCV + ML Kit Face Detection ger koordinater för Selective Gaussian Blur (hudutjämning) och ögonkontrast. Verklig tillämpning — appar Facetune, BeautyPlus, YouCam Makeup.

Uppmärksamhetskontroll — bestämning av blickriktning (gaze detection). Face Detection returnerar bounding box och landmarks för ögonen. Baserat på pupillens position i förhållande till ögat bestäms var användaren tittar: på skärmen, vänster, höger, uppåt. Tillämpas inom e-learning (kontroll att studenten tittar på föreläsningen), reklam (uppmärksamhetsmått), körassistenter (trötthetskontroll).

// ARKit + Vision för AR-filter
let faceLandmarksRequest = VNDetectFaceLandmarksRequest { req, _ in
    guard let face = req.results?.first as? VNFaceObservation else { return }
    if let leftEye = face.landmarks?.leftEye {
        // AR-objektöverlagring på vänster öga
    }
}

let handler = VNSequenceRequestHandler()
for pixelBuffer in videoStream {
    try handler.perform([faceLandmarksRequest], on: pixelBuffer)
}

Medicin och wellness — Face Detection används för analys av ansiktsasymmetri (diagnos av neurologiska störningar), utvärdering av puls genom mikro-vibrationer i huden (fotopletysmografi via kamera), bestämning av hudfuktighet. ML Kit Face Detection + OpenCV ger tillräcklig noggrannhet för preliminär screening utan medicinsk certifiering. För produktionsmedicin krävs FDA/CE-certifiering.