# OCR Pipelines and Text Extraction Architecture

**Last updated:** 2026-02
**Status:** GA
**Category:** Multi-Modal AI

---

## Introduksjon

Optical Character Recognition (OCR) er ein grunnleggjande kapabilitet for digitalisering av offentleg forvaltning. Microsoft tilbyr to hovudtenester for OCR: **Azure AI Document Intelligence** (tidlegare Form Recognizer) som er optimalisert for dokument med høg oppløysing, og **Azure AI Vision Image Analysis** (Read API) som er optimalisert for generelle bilete som skiltar, plakatar og scena-tekst.

Document Intelligence opererer på høgare oppløysing enn Vision Read og støttar utvinning av både trykt og handskriven tekst frå PDF-dokument, skanna bilete, Microsoft Office-filer (Word, Excel, PowerPoint) og HTML. Tenesta inkluderer paragrafdeteksjon, tabellgjenkjenning, figurar, utvalgsmerke og språkdeteksjon. Read-modellen er OCR-motoren som ligg under alle andre Document Intelligence-modellar (Layout, Invoice, Receipt, ID Document, osv.).

For norsk offentleg sektor er robust OCR kritisk for digitalisering av arkiv, automatisering av saksbehandling, uttrekk av data frå skjema og faktura, og tilgjengeleggjering av historiske dokument. Azure Document Intelligence v4.0 (GA) tilbyr Batch API for store volum, searchable PDF-output, og add-on capabilities som høgoppløyseleg OCR, språkdeteksjon og query fields.

---

## Kjernekomponentar

| Komponent | Formål | Teknologi |
|-----------|--------|-----------|
| Document Intelligence Read | Dokument-optimalisert OCR med paragrafar | Azure AI Document Intelligence v4.0 |
| Document Intelligence Layout | Strukturert uttrekk (tabellar, figurar) | Azure AI Document Intelligence v4.0 |
| Vision Read API | Generell scene-tekst OCR | Azure AI Vision 4.0 |
| Prebuilt Models | Feltuttrekk frå faktura, kvittering, ID | Azure AI Document Intelligence |
| Custom Models | Trenable modellar for eigne dokumenttypar | Azure AI Document Intelligence |
| Document Classifier | Automatisk dokumentklassifisering og splitting | Azure AI Document Intelligence |
| Content Understanding | Generativ AI-basert dokumentforståing | Microsoft Foundry (preview) |
| Batch API | Volumbasert asynkron prosessering | Azure AI Document Intelligence v4.0 |

---

## Image Preprocessing og Quality Assessment

### Bildekvalitetskrav

| Parameter | Document Intelligence | Vision Read |
|-----------|----------------------|-------------|
| **Format** | PDF, JPEG, PNG, BMP, TIFF, HEIF, DOCX, XLSX, PPTX, HTML | JPEG, PNG, GIF, BMP, WEBP, ICO, TIFF, MPO |
| **Maks filstorleik** | 500 MB (Standard), 4 MB (Free) | 20 MB |
| **Maks dimensjonar** | 10 000 x 10 000 px (standard) | 16 000 x 16 000 px |
| **Min dimensjonar** | 50 x 50 px | 50 x 50 px |
| **Maks sider** | 2000 sider per dokument | N/A (enkeltbilete) |

### Preprocessing-pipeline

```python
from PIL import Image, ImageEnhance, ImageFilter
import io

def preprocess_for_ocr(image_path: str) -> bytes:
    """Optimaliser bilete for best OCR-resultat."""
    img = Image.open(image_path)

    # Steg 1: Konverter til gråskala om ikkje allereie
    if img.mode != 'L':
        img = img.convert('L')

    # Steg 2: Oppskaler låg-oppløyselege bilete
    min_dimension = 1024
    if min(img.size) < min_dimension:
        scale = min_dimension / min(img.size)
        new_size = (int(img.width * scale), int(img.height * scale))
        img = img.resize(new_size, Image.LANCZOS)

    # Steg 3: Kontrastforbetring
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(1.5)

    # Steg 4: Skarpheit
    img = img.filter(ImageFilter.SHARPEN)

    # Steg 5: Binarisering for svært dårlege skanningar
    # (valfritt — bruk berre for ekstremt dårlege bilete)
    # threshold = 128
    # img = img.point(lambda p: 255 if p > threshold else 0)

    buffer = io.BytesIO()
    img.save(buffer, format="PNG", dpi=(300, 300))
    return buffer.getvalue()
```

### Kvalitetsmetrikkar

```python
def assess_image_quality(image_path: str) -> dict:
    """Vurder bildekvalitet for OCR."""
    img = Image.open(image_path)

    quality = {
        "resolution": {
            "width": img.width,
            "height": img.height,
            "dpi_estimated": min(img.width, img.height) / 8.27,
            "sufficient": min(img.width, img.height) >= 500
        },
        "format": {
            "mode": img.mode,
            "format": img.format,
            "is_optimal": img.format in ["PNG", "TIFF"]
        },
        "recommendation": []
    }

    if quality["resolution"]["dpi_estimated"] < 150:
        quality["recommendation"].append(
            "Oppløysing er låg — bruk OCR_HIGH_RESOLUTION add-on"
        )
    if img.mode == "RGBA":
        quality["recommendation"].append(
            "Konverter frå RGBA til RGB for raskare prosessering"
        )

    return quality
```

---

## OCR Engine Selection og Configuration

### Hovudval: Document Intelligence vs Vision Read

| Kriterium | Document Intelligence Read | Vision Read API |
|-----------|---------------------------|-----------------|
| **Brukscase** | Dokument (PDF, skanningar, Office) | Scene-tekst (skiltar, plakatar) |
| **Oppløysing** | Høgare (doc-optimalisert) | Standard |
| **Handskrift** | Ja — premium | Ja — grunnleggjande |
| **Tabellar** | Ja (Layout-modell) | Nei |
| **Strukturert output** | Paragrafar, seksjonar, figurar | Liner og ord |
| **Fleirspråkleg** | 300+ språk/lokalar | 100+ språk |
| **Batch** | Ja (Batch API) | Nei (synkron) |
| **Output til PDF** | Searchable PDF | Nei |

### Document Intelligence Read — Python SDK

```python
import os
from azure.core.credentials import AzureKeyCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import (
    AnalyzeResult,
    AnalyzeDocumentRequest,
    DocumentAnalysisFeature
)

client = DocumentIntelligenceClient(
    endpoint=os.environ["DI_ENDPOINT"],
    credential=AzureKeyCredential(os.environ["DI_KEY"])
)

# Analyser dokument med high-resolution OCR
with open("scanned_document.pdf", "rb") as f:
    poller = client.begin_analyze_document(
        "prebuilt-read",
        body=f,
        features=[DocumentAnalysisFeature.OCR_HIGH_RESOLUTION]
    )

result: AnalyzeResult = poller.result()

# Utvinne språkdeteksjon
if result.languages:
    for lang in result.languages:
        print(f"Språk: {lang.locale} "
              f"(confidence: {lang.confidence:.2f})")

# Utvinne handskrift-stil
if result.styles:
    for style in result.styles:
        if style.is_handwritten:
            text = ",".join([
                result.content[s.offset:s.offset + s.length]
                for s in style.spans
            ])
            print(f"Handskriven tekst: {text}")

# Utvinne paragrafar
for para in result.paragraphs:
    print(f"[{para.role}] {para.content}")

# Utvinne sider, liner og ord
for page in result.pages:
    print(f"--- Side {page.page_number} ---")
    print(f"Dimensjonar: {page.width}x{page.height} {page.unit}")
    for line in page.lines:
        print(f"  Linje: {line.content}")
        for word in page.words:
            if word.confidence < 0.7:
                print(f"    [LAV CONFIDENCE] {word.content}: "
                      f"{word.confidence:.2f}")
```

### Layout-modellen for strukturert uttrekk

```python
# Layout gir tabellar, figurar og seksjonar i tillegg til OCR
poller = client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=document_url)
)
result = poller.result()

# Tabellar
for table_idx, table in enumerate(result.tables):
    print(f"Tabell {table_idx}: "
          f"{table.row_count} rader x {table.column_count} kolonnar")
    for cell in table.cells:
        print(f"  [{cell.row_index}][{cell.column_index}]: "
              f"{cell.content}")

# Figurar (med bounding regions)
if result.figures:
    for fig in result.figures:
        print(f"Figur: {fig.caption.content if fig.caption else 'Utan caption'}")
```

---

## Text Normalization og Correction

### Post-OCR normalisering

```python
import re
from typing import Optional

def normalize_ocr_text(raw_text: str,
                       locale: str = "nb-NO") -> str:
    """Normaliser OCR-tekst for norsk kontekst."""

    text = raw_text

    # Fiks vanlege OCR-feil i norsk tekst
    ocr_corrections = {
        r'\b0\b(?=[a-zA-Z])': 'O',      # 0 → O framfor bokstavar
        r'(?<=[a-zA-Z])\b0\b': 'o',      # 0 → o etter bokstavar
        r'l(?=[0-9])': '1',               # l → 1 framfor tal
        r'(?<=[0-9])O': '0',             # O → 0 etter tal
        r'æ\s': 'æ',                      # Fjern spacing i æøå
        r'ø\s': 'ø',
        r'å\s': 'å',
    }

    for pattern, replacement in ocr_corrections.items():
        text = re.sub(pattern, replacement, text)

    # Normaliser personnummer-format
    text = re.sub(
        r'(\d{6})\s*(\d{5})',
        r'\1 \2',
        text
    )

    # Normaliser organisasjonsnummer
    text = re.sub(
        r'(\d{3})\s*(\d{3})\s*(\d{3})',
        r'\1 \2 \3',
        text
    )

    # Fjern OCR-artifact (stray pikslar som vert tolka som teikn)
    text = re.sub(r'[^\w\s.,;:!?()@\-/\\æøåÆØÅ€£$%&#+*]', '', text)

    return text.strip()


def extract_structured_fields(ocr_result: AnalyzeResult) -> dict:
    """Utvinne strukturerte felt frå OCR-resultat."""
    fields = {}

    for para in ocr_result.paragraphs:
        content = para.content.strip()

        # Detekter datoar
        date_match = re.search(
            r'(\d{1,2})[./-](\d{1,2})[./-](\d{2,4})',
            content
        )
        if date_match:
            fields.setdefault("dates", []).append(date_match.group())

        # Detekter beløp (NOK)
        amount_match = re.search(
            r'kr\.?\s*([\d\s]+[,.]?\d*)',
            content, re.IGNORECASE
        )
        if amount_match:
            fields.setdefault("amounts", []).append(
                amount_match.group(1).strip()
            )

    return fields
```

---

## Integration with Document Understanding

### End-to-end OCR Pipeline

```
Innkommande dokument (PDF/bilete)
    → Steg 1: Kvalitetsvurdering (preprocessing)
    → Steg 2: Dokumentklassifisering (Custom Classifier)
    → Steg 3: OCR + Strukturert uttrekk
        → Faktura → prebuilt-invoice
        → Kvittering → prebuilt-receipt
        → ID-dokument → prebuilt-idDocument
        → Generelt → prebuilt-layout + query fields
    → Steg 4: Post-processing (normalisering, validering)
    → Steg 5: Integrasjon (Cosmos DB, AI Search, Power Automate)
```

### Query Fields for fleksibelt feltuttrekk

```python
# Utvinne spesifikke felt utan modelltrening
poller = client.begin_analyze_document(
    "prebuilt-layout",
    AnalyzeDocumentRequest(url_source=doc_url),
    features=[DocumentAnalysisFeature.QUERY_FIELDS],
    query_fields=["Saksnummer", "Vedtaksdato", "Klagerist",
                   "Ansvarlig saksbehandler"]
)
result = poller.result()

for doc in result.documents:
    for field_name, field_value in doc.fields.items():
        print(f"{field_name}: {field_value.get('valueString')}")
```

### Searchable PDF Output

```python
from azure.ai.documentintelligence.models import AnalyzeOutputOption

# Konverter skanna PDF til søkbar PDF
with open("scanned.pdf", "rb") as f:
    poller = client.begin_analyze_document(
        "prebuilt-read",
        body=f,
        output=[AnalyzeOutputOption.PDF]
    )

result = poller.result()
operation_id = poller.details["operation_id"]

# Last ned searchable PDF
response = client.get_analyze_result_pdf(
    model_id=result.model_id,
    result_id=operation_id
)

with open("searchable_output.pdf", "wb") as writer:
    writer.writelines(response)
```

### Azure AI Search Integration

```json
{
  "@odata.type": "#Microsoft.Skills.Vision.OcrSkill",
  "context": "/document/normalized_images/*",
  "detectOrientation": true,
  "inputs": [
    {"name": "image", "source": "/document/normalized_images/*"}
  ],
  "outputs": [
    {"name": "text", "targetName": "ocrText"},
    {"name": "layoutText", "targetName": "ocrLayoutText"}
  ]
}
```

Kombiner med Text Merge skill for å slå saman OCR-tekst med dokumenttekst:

```json
{
  "@odata.type": "#Microsoft.Skills.Text.MergeSkill",
  "context": "/document",
  "inputs": [
    {"name": "text", "source": "/document/content"},
    {"name": "itemsToInsert", "source": "/document/normalized_images/*/ocrText"}
  ],
  "outputs": [
    {"name": "mergedText", "targetName": "merged_content"}
  ]
}
```

---

## Norsk offentleg sektor

### Bruksområde
- **Arkivdigitalisering**: OCR av historiske dokument og protokollar
- **Saksbehandling**: Automatisk uttrekk frå innkomne dokument
- **Fakturaprosessering**: Prebuilt invoice model for leverandørfaktura
- **ID-verifisering**: Prebuilt ID document model for pass og førarkort
- **Byggesak**: Uttrekk av informasjon frå teikningar og plankartet

### Språkstøtte for norsk
- Document Intelligence: Norsk bokmål (`nb`) og nynorsk (`nn`) støtta
- Handskriftgjenkjenning: Støttar norske teikn (æ, ø, å)
- High-resolution OCR: Forbetrar resultat for gamle, dårlege skanningar

### GDPR og personvern
- Document Intelligence er stateless — ingen lagring etter analyse
- For PDF med personnummer: Sladding etter OCR-uttrekk
- Batch API-resultat lagrast i Microsoft-managed container eller eigen Azure Storage
- Anbefaling: Bruk customer-managed key for kryptering av mellomlagring

---

## Beslutningsrammeverk

| Scenario | Anbefaling | Grunngjeving |
|----------|------------|--------------|
| PDF-dokumentanalyse | Document Intelligence Read/Layout | Beste OCR for dokument |
| Skiltar og scene-tekst | Vision Read API | Optimalisert for generelle bilete |
| Faktura/kvittering | Document Intelligence prebuilt | Ferdig modell med feltuttrekk |
| Eigendefinerte skjema | Custom Model + query fields | Fleksibelt utan full modelltrening |
| Store volum (10K+ dokument) | Batch API | Asynkron, kostnadseffektiv |
| Historiske dokument (dårleg kvalitet) | OCR_HIGH_RESOLUTION add-on | Høgare oppløysing for betre resultat |
| Søkbar PDF frå skanning | Read + AnalyzeOutputOption.PDF | Innebygd searchable PDF |
| RAG-pipeline | AI Search + OCR Skill + Text Merge | End-to-end indeksering |

---

## For Cosmo

- **Azure AI Document Intelligence v4.0 er standard for dokument-OCR** — høgare oppløysing enn Vision Read, støttar PDF/Office/HTML, og inkluderer paragrafdeteksjon, tabellar og handskrift med confidence scores per ord.
- **Prebuilt-modellar eliminerer behovet for trening** — invoice, receipt, ID document og layout dekkjer dei vanlegaste scenarioa i offentleg forvaltning, med query fields for fleksibelt feltuttrekk utan modelltrening.
- **Batch API er essensielt for volum-digitalisering** — asynkron prosessering av tusenvis av dokument med resultat i Azure Blob Storage, eigna for arkivdigitaliseringsprosjekt.
- **Searchable PDF er ein game-changer for arkiv** — konverter skanna dokument til søkbare PDF-ar med innebygd tekst-layer, direkte brukbare i saksbehandlingssystem og arkivløysingar.
- **OCR_HIGH_RESOLUTION add-on er kritisk for dårlege skanningar** — aktiverer høgare oppløysing for historiske dokument, handskrivne notat og låg-kvalitets-kopiar som er vanlege i offentlege arkiv.
