Text Recognition i applikationer — vad är det, OCR och Vision

Vad är Text Recognition: OCR-principer

Text Recognition (OCR) — datorseendeprocess som omvandlar en bild av text till maskinläsbara tecken. OCR består av steg: förbehandling av bild (binarisering, deskew, korrigering av lutning), segmentering (uppdelning i rader, ord, tecken), igenkänning (klassificering av varje tecken) och efterbehandling (kontroll med ordbok, korrigering av fel). Moderna OCR-system (ML Kit, Vision) använder end-to-end neurala nätverk som kombinerar alla steg.

Typer av OCR: tryckt text (printed text) — igenkänning av maskinskriven text från dokument, skyltar, skärmar — noggrannhet 95–99%; handskriven text (handwriting) — igenkänning av handskriven inmatning — noggrannhet 80–90% för latinska, 70–80% för kyrilliska; scen text (scene text) — text i naturliga scener: husnummer, vägskyltar, butiksnamn — svårast på grund av perspektivförvrängningar och blänk.

CRNN + CTC Loss — arkitektur som används i moderna OCR-modeller. Convolutional Recurrent Neural Network (CNN + LSTM) extraherar bildegenskaper och Connectionist Temporal Classification avkodar teckensekvensen utan behov av försegmentering. CRNN fungerar med texter av valfri längd, är motståndskraftig mot lutning och förvrängningar. Enligt arXiv (2025) ger CRNN-modeller 97.5% noggrannhet på benchmark ICDAR 2019.

CRNN för mobila enheter — ML Kit använder modellen MobileNetV2 + CRNN med INT8-kvantisering. Modellen upptar 2–5 MB (latent) och körs på GPU/NPU via TFLite Delegate. Till skillnad från Tesseract (klassisk pipeline) kräver neuralt nätverks-OCR inte separat teckensegmentering och är mer motståndskraftigt mot brus. Nackdel: kräver GPU eller NPU för realtid — på ren CPU sjunker hastigheten till 5–10 FPS.

ML Kit Text Recognition på Android och iOS

ML Kit Text Recognition — det främsta OCR-verktyget för mobila applikationer. Finns i två versioner: V2 (Latin-based — optimerad för latinska, kyrilliska tecken, siffror) och V1 (Latin + CJK — japanska, kinesiska, koreanska, men långsammare). V2 använder en end-to-end CRNN-modell, V1 — äldre CNN + LSTM. Google rekommenderar V2 för alla fall utom när CJK-igenkänning behövs.

Struktur för ML Kit-resultat: Text → TextBlock → Line → Element (Word/Symbol). Varje nivå har en bounding box, confidence (0..1) och recognised text. Text — rotobjekt med fullText (all igenkänd text på en rad). TextBlock — logiskt textblock (stycke, kolumn). Line — textrad. Element — ord eller symbol. Använd confidence för att filtrera bort inexakta igenkänningar.

// ML Kit Text Recognition V2
val recognizer = TextRecognition.getClient(
    TextRecognizerOptions.DEFAULT_OPTIONS
)

recognizer.process(inputImage)
    .addOnSuccessListener { text ->
        val fullText = text.text
        text.textBlocks.forEach { block ->
            val blockText = block.text
            val blockRect = block.boundingBox
            block.lines.forEach { line ->
                line.elements.forEach { element ->
                    val word = element.text
                    val confidence = element.confidence
                }
            }
        }
    }
    .addOnFailureListener { error -> /* error */ }

Text Recognition på iOS via ML Kit: API liknar Android men använder UIImage/CVPixelBuffer istället för InputImage. ML Kit använder automatiskt Apple Neural Engine på A12+ via Core ML Delegate. För iOS visar ML Kit Text Recognition V2 en hastighet på 15–30 ms på iPhone 15 Pro. För maximal prestanda, konvertera UIImage till CVPixelBuffer före överföring — detta minskar konverteringsomkostnader.

Apple Vision Framework: VNRecognizeTextRequest

Apple Vision Framework tillhandahåller inbyggt OCR via VNRecognizeTextRequest (iOS 13+). Vision OCR använder Apple Neural Engine (ANE) och kräver inga extra SDK:er. Stöder 13 språk (EN, FR, IT, DE, ES, PT, ZH, JP, KO, RU, AR, TH, VI). Vision identifierar automatiskt textens språk (language correction) och stöder flera språk i en enda bildruta. Hastighet — 10–40 ms på A16+.

Vision OCR-funktioner: recognitionLevel (fast vs accurate), automaticLanguageDetection, customWords (lägga till specifika termer), stöd för top candidates (flera igenkänningsvarianter för otydlig text). Fast-läge ger 90% noggrannhet vid 10–20 ms, accurate — 95% vid 30–50 ms. För produktion, använd accurate med filtrering på confidence >= 0.5.

import Vision

let request = VNRecognizeTextRequest { request, error in
    guard let observations = request.results as? [VNRecognizedTextObservation] else { return }
    for observation in observations {
        let topCandidate = observation.topCandidates(1).first
        let text = topCandidate?.string ?? ""
        let confidence = topCandidate?.confidence ?? 0
        let boundingBox = observation.boundingBox
    }
}
request.recognitionLevel = .accurate
request.usesLanguageCorrection = true

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

Vision vs ML Kit på iOS: Vision är snabbare på äldre enheter (iPhone X–13) tack vare inbyggd ANE. ML Kit är mer exakt på komplexa scener (förvrängningar, lutningar, blänk) tack vare Google-modellen tränad på miljontals scene text-bilder. Vision stöder inte confidence för enskilda tecken (endast för ord), vilket begränsar filtrering. För dokument — Vision (snabbare), för scene text — ML Kit (mer exakt).

Tesseract OCR: open-source-alternativ

Tesseract OCR — open-source textigenkänningsmotor, utvecklad av HP (1985–1998) och fortsatt av Google (2006+). Tesseract 5 (LSTM-based) använder CRNN neural nätverksarkitektur, vilket ger en betydande noggrannhetsökning jämfört med Tesseract 4 (klassisk + LSTM). Tesseract stöder 100+ språk, inklusive kyrilliska, arabiska, hebreiska och CJK. För Android — tess-two (fork), för iOS — swift-tesseract.

Nackdelar med Tesseract: hastighet 50–200 ms per bildruta (CPU-only, ingen GPU-acceleration), kräver förbehandling av bild (binarisering, deskew, bestämning av orientering) före överföring till motorn, har ingen inbyggd textdetektion — bildområdet måste skickas (ofta i par med OpenCV Text Detection eller EAST). Tesseract ger 90% noggrannhet på rena dokument och ~70% på scene text.

När ska man välja Tesseract: om appen körs på enheter utan Google Play (Huawei), stöd för sällsynta språk (sanskrit, hebreiska) behövs, eller fullständig anpassning av OCR-pipelinen (träning på egna typsnitt) krävs. I alla andra fall är ML Kit eller Vision snabbare, mer exakt och kräver mindre kod. Tesseract är ett motiverat val endast när det finns begränsningar för tredjeparts-SDK:er.

// Tesseract OCR via tess-two
val tess = TessBaseAPI()
tess.init(dataPath, "rus+eng")
tess.pageSegMode = TessBaseAPI.PageSegMode.PSM_AUTO

val bitmap = BitmapFactory.decodeResource(resources, R.drawable.text)
val gray = Bitmap.createBitmap(bitmap.width, bitmap.height, Bitmap.Config.ARGB_8888)
OpenCV.process(bitmap, gray) // Binarisering + deskew

tess.setImage(gray)
val result = tess.utF8Text
tess.recycle()

Förbehandling för Tesseract är obligatorisk: konvertering till gråskala, binarisering (Otsu eller Adaptive), korrigering av lutning (deskew), brusborttagning (median blur). Utan förbehandling sjunker Tesseracts noggrannhet till 50–60%. Använd OpenCV för förbehandling: Imgproc.cvtColor → Imgproc.threshold → Imgproc.erode/dilate → Core.rotate (deskew). För dokument med jämn bakgrund räcker binarisering, för scene text — full pipeline.

Förbehandling av bilder för OCR

Bildkvalitet — den viktigaste faktorn för OCR-noggrannhet. ML Kit och Vision har inbyggd förbehandling, men för komplexa fall (mörka foton, oskärpa, överexponering) ökar extra bearbetning noggrannheten med 10–15%. Huvudtekniker: kontrastökning (CLAHE), borttagning av oskärpa (unsharp mask), perspektivkorrigering (perspective transform), borttagning av skuggor och blänk.

CLAHE (Contrast Limited Adaptive Histogram Equalization) — adaptiv histogramutjämning med kontrastbegränsning, som förbättrar kontrasten i lokala områden. CLAHE är effektivt för dokumentfoton med ojämn belysning (del i skugga, del i ljus). OpenCV Core.createCLAHE med clipLimit=2.0 och tileGridSize=(8,8) ger optimalt resultat för OCR. Efter CLAHE ökar ML Kit-noggrannheten på mörka dokument från 70% till 88%.

Perspektivkorrigering — obligatorisk för dokumentfoton tagna i vinkel. Använd OpenCV findHomography + warpPerspective för att rikta in dokumentet. För automatisk detektering av dokumentkanter, använd Canny edge detection + findContours + approxPolyDP. Efter perspektivkorrigering ökar OCR-noggrannheten med 20–30% för bilder tagna i vinkel >30°.

// CLAHE + OpenCV-förbehandling
val mat = Mat()
Utils.bitmapToMat(bitmap, mat)
Imgproc.cvtColor(mat, mat, Imgproc.COLOR_RGB2GRAY)

val clahe = Imgproc.createCLAHE(2.0, Size(8.0, 8.0))
clahe.apply(mat, mat)

Imgproc.GaussianBlur(mat, mat, Size(3.0, 3.0), 0.0)
Imgproc.threshold(mat, mat, 0.0, 255.0, Imgproc.THRESH_BINARY or Imgproc.THRESH_OTSU)

val processedBitmap = Bitmap.createBitmap(mat.cols(), mat.rows(), Bitmap.Config.ARGB_8888)
Utils.matToBitmap(mat, processedBitmap)

Textdetektion före OCR — för scene text, använd EAST (Efficient Accurate Scene Text Detector) eller CRAFT (Character Region Awareness for Text Detection) före överföring till OCR. EAST detekterar textens bounding box i scenen på 5–15 ms. CRAFT är mer exakt (97%), men långsammare (50–100 ms). Textdetektion gör det möjligt att beskära områden utan text och endast skicka relevanta delar till OCR, vilket påskyndar den totala bearbetningen.

Tillämpning av OCR i mobila applikationer

Dokumentskanning — den mest omfattande tillämpningen av OCR. Skanningsappar (CamScanner, Adobe Scan, Google Drive) använder ML Kit eller Vision för textigenkänning från dokumentfoton. Typisk pipeline: detektering av dokumentkanter → perspektivkorrigering → CLAHE-bearbetning → OCR → formatering (PDF, DOCX). ML Kit Text Recognition V2 bearbetar en A4-sida på 100–200 ms.

Realtidsöversättning av text — kombination av OCR och maskinöversättning. Google Translate, Microsoft Translator, Yandex Translate använder ML Kit eller Vision för textigenkänning från kameran och lägger översättningen över originaltexten (AR-översättning). Krav: latens < 200 ms för bekväm användarupplevelse. ML Kit V2 + NNAPI ger 30–80 ms per bildruta, med utrymme för översättning och rendering.

Automatisk datainmatning — OCR för att extrahera data från visitkort, bankkort, identitetshandlingar. ML Kit känner igen texten, sedan tolkar efterbehandlingen strukturen: namn, telefon, e-post (visitkort) eller kortnummer, utgångsdatum, CVV (betalningskort). För visitkort, använd reguljära uttryck efter OCR. För bankkort — specialiserade ML-modeller (betalda, ~99% noggrannhet).

// OCR + AR-översättning (förenklad)
let request = VNRecognizeTextRequest { req, _ in
    guard let results = req.results as? [VNRecognizedTextObservation] else { return }
    for observation in results {
        let text = observation.topCandidates(1).first?.string ?? ""
        let rect = observation.boundingBox
        // Översättning och AR-rendering över rektangel
        DispatchQueue.main.async {
            overlayView.showTranslation(text, at: rect)
        }
    }
}
request.recognitionLevel = .fast
request.usesLanguageCorrection = false

OCR för personer med synnedsättning — Hjälpmedelsteknik: appar läser upp text från förpackningar, menyer, skyltar. De använder ML Kit OCR + Text-to-Speech (Android TTS / iOS AVSpeechSynthesizer). Nyckelkrav — realtid med låg latens (< 100 ms). Seeing AI (Microsoft) och Envision AI använder denna metod. För tillgänglighetsappar, använd fast recognition-läge och filtrera inte efter confidence — varje text är viktig för användaren.