Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Vergelijking van meerdere afbeeldingen

Les 8 van 12 Bijgewerkt op 30 juli 2026 Beginner
Op deze pagina
  1. Meerdere afbeeldingen in één verzoek analyseren
  2. Structuur van een verzoek met meerdere afbeeldingen
  3. Use case: Voor-/na-vergelijking
  4. Use case: Tijdsopvolging
  5. Use case: Kwaliteitscontrole
  6. Use case: Concurrentieanalyse
  7. Verzoeken met meerdere afbeeldingen optimaliseren
  8. Belangrijkste punten

Meerdere afbeeldingen in één verzoek analyseren

Een van de belangrijkste sterke punten van Grok Vision is de mogelijkheid om een onbeperkt aantal afbeeldingen in één enkel verzoek te verzenden. Dit opent unieke mogelijkheden voor vergelijking, tijdsopvolging en kruisanalyse die API’s voor één afbeelding niet kunnen bieden.

Structuur van een verzoek met meerdere afbeeldingen

De indeling is eenvoudig: voeg zoveel input_image-objecten toe als nodig is aan de input-array, afgewisseld met tekst om de analyse te sturen:

response = client.responses.create(
    model="grok-4.5",
    input=[
        {"type": "input_text", "text": "Image A:"},
        {"type": "input_image", "image_url": url_image_a},
        {"type": "input_text", "text": "Image B:"},
        {"type": "input_image", "image_url": url_image_b},
        {"type": "input_text", "text": "Compare these two images in detail."}
    ]
)

Het labelen van elke afbeelding met tekst (“Afbeelding A”, “Afbeelding B”) helpt het model om zijn reactie te structureren en duidelijk naar elke afbeelding te verwijzen.

Use case: Voor-/na-vergelijking

Ideaal voor projectopvolging, renovatie, ontwerp of kwaliteitscontrole:

def comparer_avant_apres(url_avant, url_apres):
    prompt = """Compare these two images (before and after) and identify:

1. The main changes
2. Elements that have not changed
3. Visible improvements
4. Any potential issues introduced

Present your response as a structured list."""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "BEFORE:"},
            {"type": "input_image", "image_url": url_avant, "detail": "high"},
            {"type": "input_text", "text": "AFTER:"},
            {"type": "input_image", "image_url": url_apres, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Use case: Tijdsopvolging

Volg de evolutie van een locatie, product of proces in de tijd:

def analyser_evolution(images_chronologiques):
    """images_chronologiques: list of {"url": ..., "date": ...}"""
    input_data = []

    for img in images_chronologiques:
        input_data.append({
            "type": "input_text",
            "text": f"Photo from {img['date']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": img["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Analyze the chronological evolution visible in
these images. Identify progressive changes, trends,
and any notable events between the different dates."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Use case: Kwaliteitscontrole

Vergelijk een gefabriceerd product met zijn referentiemodel:

def controle_qualite(url_reference, url_produit):
    prompt = """Compare the photographed product to the reference model.

Identify:
1. Compliance (what matches the model)
2. Non-compliance (deviations, defects, differences)
3. Severity of each non-compliance (minor, major, critical)

Return a JSON with:
{
  "compliant": true/false,
  "score": 0-100,
  "compliances": [...],
  "non_compliances": [
    {"description": "...", "severity": "minor|major|critical"}
  ]
}"""

    response = client.responses.create(
        model="grok-4.5",
        input=[
            {"type": "input_text", "text": "REFERENCE (expected model):"},
            {"type": "input_image", "image_url": url_reference, "detail": "high"},
            {"type": "input_text", "text": "PRODUCT to check:"},
            {"type": "input_image", "image_url": url_produit, "detail": "high"},
            {"type": "input_text", "text": prompt}
        ],
        store=False
    )
    return response.output_text

Use case: Concurrentieanalyse

Vergelijk interfaces, verpakkingen of productpresentaties van concurrenten:

def analyser_concurrence(images_concurrents):
    """images_concurrents: [{"brand": "...", "url": "..."}]"""
    input_data = []

    for concurrent in images_concurrents:
        input_data.append({
            "type": "input_text",
            "text": f"{concurrent['brand']}:"
        })
        input_data.append({
            "type": "input_image",
            "image_url": concurrent["url"],
            "detail": "auto"
        })

    input_data.append({
        "type": "input_text",
        "text": """Compare these competitor products/interfaces.
For each, identify visual strengths and weaknesses.
Provide a positioning recommendation."""
    })

    response = client.responses.create(
        model="grok-4.5",
        input=input_data,
        store=False
    )
    return response.output_text

Verzoeken met meerdere afbeeldingen optimaliseren

Wanneer u veel afbeeldingen verzendt, stijgt het tokenverbruik snel. Hier zijn enkele optimalisatiestrategieën:

Het detailniveau aanpassen

Gebruik low voor algemene vergelijkingen en high alleen bij het analyseren van fijne details:

# Global comparison: low is sufficient
detail = "low"  # ~256 tokens per image

# Defect analysis: high required
detail = "high"  # ~1024-1792 tokens per image

Het aantal afbeeldingen per verzoek beperken

Hoewel er geen harde limiet is, kan de analysekwaliteit afnemen bij meer dan 10-15 afbeeldingen. Het model heeft een eindige context en moet deze over alle afbeeldingen verdelen:

# If more than 10 images, process in batches
def analyser_par_lots(images, taille_lot=10):
    resultats = []
    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]
        resultat = analyser_lot(lot)
        resultats.append(resultat)
    return fusionner_resultats(resultats)

Afbeeldingen verkleinen

Als u foto’s met hoge resolutie vergelijkt voor algemene analyse, verklein ze dan voordat u ze verzendt om tokens te besparen:

def preparer_pour_comparaison(chemin, taille_max=(800, 800)):
    img = Image.open(chemin)
    img.thumbnail(taille_max)
    # ... encode to base64

Belangrijkste punten

  • Het aantal afbeeldingen per verzoek is onbeperkt — dit is een belangrijk voordeel van de xAI-API
  • Label elke afbeelding met tekst om de analyse te structureren
  • Pas de parameter detail aan op het type vergelijking
  • Verwerk bij meer dan 10-15 afbeeldingen in batches om de kwaliteit te behouden
  • Use cases omvatten: voor/na, tijdsopvolging, kwaliteitscontrole, concurrentieanalyse