# Afbeeldingen analyseren met Gemini Vision

[[TOC]]

## Gemini Vision: wat kan het

Gemini's visuele capaciteiten gaan verder dan simpele beeldbeschrijvingen. Het model begrijpt context, verbanden en abstracte concepten in afbeeldingen. De hele Gemini 3.5-familie accepteert multimodale invoer (tekst, beeld, audio en video) en geeft tekst terug. Veelvoorkomende toepassingen:

- **Objectdetectie en classificatie**: identificeer producten, gebouwen, dieren of voertuigen.
- **OCR en tekstextractie**: lees tekst uit foto's, documenten en whiteboards.
- **Grafiek- en diagramanalyse**: interpreteer datavisualisaties, flowcharts en architectuurdiagrammen.
- **Sceneomschrijving**: genereer alt-tekst, producttitels en toegankelijkheidsbeschrijvingen.
- **Visuele vraagbeantwoording (VQA)**: beantwoord specifieke vragen over de inhoud.
- **Documentverwerking**: extraheer gestructureerde data uit formulieren en facturen.

:::warn title="Gebruik de nieuwe google-genai SDK"
De oude `google.generativeai`-bibliotheek is sinds 30 november 2025 volledig uitgefaseerd en krijgt geen nieuwe features meer. Gebruik de unified SDK `google-genai`, die je importeert met `from google import genai`. De voorbeelden hieronder gebruiken die SDK en het stabiele GA-model `gemini-3.5-flash`.
:::

## De client opzetten

Zet eerst je API-sleutel in de omgeving (`GEMINI_API_KEY` of `GOOGLE_API_KEY`) en maak een client aan. Die client hergebruik je in alle voorbeelden hieronder.

```python
from google import genai
from google.genai import types
import PIL.Image

client = genai.Client()
MODEL = "gemini-3.5-flash"
```

## Een afbeelding beschrijven

Je kunt een PIL-afbeelding rechtstreeks meegeven in de `contents`-lijst, samen met je tekstprompt.

```python
image = PIL.Image.open("kantoor.jpg")

response = client.models.generate_content(
    model=MODEL,
    contents=[image, "Beschrijf gedetailleerd wat er op deze afbeelding te zien is."]
)
print(response.text)
```

## Tekst lezen uit afbeeldingen (OCR)

Gemini presteert goed bij het lezen van gedrukte en handgeschreven tekst.

```python
image = PIL.Image.open("factuur.jpg")

response = client.models.generate_content(
    model=MODEL,
    contents=[image, "Extraheer alle tekst uit deze afbeelding en bewaar de originele opmaak zoveel mogelijk."]
)
print(response.text)
```

Voor gestructureerde extractie (factuurvelden, formulierdata) vraag je JSON terug en forceer je dat met `response_mime_type`. Zo hoef je niet handmatig markdown of losse zinnen op te schonen.

```python
import json

prompt = """Extraheer de volgende velden uit deze factuur en retourneer JSON:
{
  "factuurnummer": "",
  "datum": "",
  "klant": "",
  "totaalbedrag": "",
  "btw": ""
}"""

response = client.models.generate_content(
    model=MODEL,
    contents=[image, prompt],
    config=types.GenerateContentConfig(response_mime_type="application/json")
)

data = json.loads(response.text)
```

## Objecten lokaliseren met bounding boxes

Gemini kan coordinaten teruggeven voor gedetecteerde objecten. Vraag het model expliciet om `box_2d` in het formaat `[ymin, xmin, ymax, xmax]`, genormaliseerd naar 0 tot 1000. Reken de waarden daarna terug naar pixels met de werkelijke breedte en hoogte van je afbeelding.

```python
import json

image = PIL.Image.open("winkel.jpg")
prompt = """Detecteer alle producten in deze afbeelding.
Geef per product een object met:
- "label": de naam van het product
- "box_2d": [ymin, xmin, ymax, xmax], genormaliseerd naar 0-1000
Retourneer een JSON-array."""

response = client.models.generate_content(
    model=MODEL,
    contents=[image, prompt],
    config=types.GenerateContentConfig(response_mime_type="application/json")
)

width, height = image.size
for item in json.loads(response.text):
    ymin, xmin, ymax, xmax = item["box_2d"]
    px = (xmin / 1000 * width, ymin / 1000 * height,
          xmax / 1000 * width, ymax / 1000 * height)
    print(item["label"], px)
```

:::tip title="Vraag altijd om JSON bij coordinaten"
Stel `response_mime_type="application/json"` in en beschrijf de gewenste velden letterlijk in je prompt. Zo voorkom je dat het model uitleg of markdown toevoegt en kun je het antwoord direct met `json.loads` parsen.
:::

## Diagrammen en grafieken analyseren

```python
response = client.models.generate_content(
    model=MODEL,
    contents=[
        PIL.Image.open("verkoop_grafiek.png"),
        """Analyseer deze grafiek:
        1. Wat is het type grafiek?
        2. Wat zijn de assen en eenheden?
        3. Wat is de trend over tijd?
        4. Wat zijn de hoogste en laagste waarden?
        5. Welke conclusie kun je trekken?"""
    ]
)
print(response.text)
```

## Meerdere afbeeldingen vergelijken

Je kunt meerdere afbeeldingen en bijbehorende labels in een enkele `contents`-lijst plaatsen. De volgorde blijft behouden, dus het model weet welk label bij welke afbeelding hoort.

```python
img1 = PIL.Image.open("product_oud.jpg")
img2 = PIL.Image.open("product_nieuw.jpg")

response = client.models.generate_content(
    model=MODEL,
    contents=[
        "Vergelijk deze twee productafbeeldingen:",
        "Oud ontwerp:", img1,
        "Nieuw ontwerp:", img2,
        "Wat zijn de visuele verschillen? Welk ontwerp oogt professioneler?"
    ]
)
print(response.text)
```

## Een afbeelding via de Files API uploaden

Voor grotere afbeeldingen, hergebruik over meerdere verzoeken of bestanden boven de inline-limiet upload je het bestand eerst en geef je de referentie mee.

```python
my_file = client.files.upload(file="hoge_resolutie_scan.png")

response = client.models.generate_content(
    model=MODEL,
    contents=[my_file, "Lees alle tekst uit dit gescande document."]
)
print(response.text)
```

## Resolutie en kwaliteit afstemmen

Gemini 3 geeft je controle over hoeveel tokens een afbeelding mag kosten via de `media_resolution`-instelling. Een hogere resolutie kost meer tokens maar leest kleine tekst en details beter. De globale instelling staat in `GenerateContentConfig`.

| Niveau | Tokens per afbeelding | Geschikt voor |
| --- | --- | --- |
| `media_resolution_low` | circa 280 | snelle classificatie, grof beeld |
| `media_resolution_medium` | circa 560 | algemene beschrijving |
| `media_resolution_high` | circa 1120 | kleine lettertjes, dichte documenten |
| `media_resolution_ultra_high` | maximaal | extreem fijne details |

```python
config = types.GenerateContentConfig(
    media_resolution=types.MediaResolution.MEDIA_RESOLUTION_HIGH
)

response = client.models.generate_content(
    model=MODEL,
    contents=[PIL.Image.open("gebruiksaanwijzing.jpg"),
              "Lees alle kleine lettertjes in de gebruiksaanwijzing."],
    config=config
)
print(response.text)
```

## Alt-tekst genereren voor toegankelijkheid

```python
def generate_alt_text(image_path: str) -> str:
    image = PIL.Image.open(image_path)
    response = client.models.generate_content(
        model=MODEL,
        contents=[
            image,
            """Genereer beknopte alt-tekst voor deze afbeelding (maximaal 125 tekens).
            Beschrijf de essentiele visuele inhoud voor iemand die de afbeelding niet kan zien.
            Begin niet met 'Afbeelding van' of 'Foto van'."""
        ]
    )
    return response.text.strip()
```

:::faq
### Welke SDK en welk model gebruik ik in 2026?
Gebruik de unified `google-genai` SDK, die je importeert met `from google import genai`. De oude `google.generativeai`-bibliotheek is sinds 30 november 2025 uitgefaseerd. Het stabiele GA-model voor vision is `gemini-3.5-flash`, dat sinds 19 mei 2026 algemeen beschikbaar is.

### Herkent Gemini gezichten van specifieke personen?
Nee. Gemini weigert gezichtsidentificatie van privepersonen om privacyredenen. Het kan wel gezichtsuitdrukkingen, emoties en het aantal mensen op een foto beschrijven.

### Werkt Gemini Vision met handgeschreven tekst?
Ja, met wisselende nauwkeurigheid. Duidelijk handschrift leest het model goed, krabbelschrift is minder betrouwbaar. Zet `media_resolution` op een hoger niveau voor handgeschreven documenten.

### Hoe nauwkeurig is de kleurherkenning?
Gemini herkent kleuren goed, maar is niet geschikt voor exacte kleurmeting zoals Pantone of hex-waarden. Gebruik daarvoor een computer-vision-bibliotheek zoals OpenCV.

### Kan ik een afbeelding uit een URL analyseren zonder ze op te slaan?
Ja. Download de bytes en stuur ze als inline part mee met `types.Part.from_bytes(data=image_bytes, mime_type='image/jpeg')`. Voor grotere of herbruikte bestanden is de Files API met `client.files.upload` betrouwbaarder.

### Hoeveel tokens kost een afbeelding?
Dat hangt af van `media_resolution`: ongeveer 280 tokens op laag, 560 op medium en 1120 op hoog. Kies een lager niveau voor grote batches en een hoger niveau wanneer kleine details ertoe doen.
:::