📷 Panoramax + Hugging Face
Extraire la rue sans Google Street View

🚦 Pourquoi pas Google Street View ?

La tentation est naturelle : Google Street View couvre la planète, la qualité est excellente, et il existe une Static Street View API. Pourquoi se compliquer la vie avec une alternative ?

Parce que les conditions d'utilisation interdisent précisément ce que vous voulez faire. Les Google Maps Platform Terms prohibent le téléchargement en masse, la mise en cache des imageries au-delà du strict rendu, la création de jeux de données dérivés, et — point décisif depuis les clarifications de 2024-2025 — l'usage des contenus pour entraîner ou alimenter des modèles de machine learning. Faire tourner un détecteur d'objets sur des tuiles Street View pour en extraire des POI, c'est sortir du cadre contractuel.

S'ajoutent le coût (facturation au millier d'images, vite dissuasive sur une ville entière), l'absence de métadonnées exploitables (pas d'azimut fiable ni de paramètres caméra exposés), et la dépendance à un fournisseur qui peut couper l'accès du jour au lendemain.

💡 Insight #1 — La vraie barrière n'est pas technique
Détecter une devanture sur une image Street View est trivial. Le faire légalement, à l'échelle, et republier le résultat ne l'est pas. La licence est le mur, pas le modèle de vision.

🌍 Panoramax, en deux minutes

Panoramax est le commun numérique de photos de rue géolocalisées, porté en France par l'IGN et OpenStreetMap France, et fondé sur le logiciel libre GeoVisio. C'est un réseau d'instances fédérées (l'instance IGN, l'instance OSM-FR, des instances de collectivités…) qui partagent une API commune.

Les points qui changent tout pour notre cas d'usage :

• Licences ouvertes — les photos sont publiées sous des licences explicites (typiquement CC-BY-SA ou équivalent ouvert), qui autorisent la réutilisation et le traitement automatisé, attribution et partage à l'identique en contrepartie.
• API standard STAC — recherche par emprise (bbox), collections (séquences), items géolocalisés avec assets image en plusieurs résolutions.
• Métadonnées riches — chaque vue expose sa position, son azimut (cap), l'horodatage et des infos caméra : tout ce qu'il faut pour rétro-projeter une détection au sol.
• RGPD by design — visages et plaques d'immatriculation sont floutés automatiquement côté serveur avant publication.

💡 Insight #2 — Open data ≠ domaine public
CC-BY-SA vous donne le droit d'extraire et de republier, mais impose l'attribution et le partage à l'identique. Le dataset que vous produisez à partir de Panoramax hérite d'obligations. À anticiper avant la prod, pas après.

📊 Google Street View vs Panoramax pour l'extraction IA

La conclusion est nette : sur la couverture brute, Google gagne. Sur le droit d'en faire quelque chose et de le republier, Panoramax est le seul terrain de jeu praticable. Et dans une logique de contribution OSM, les deux mondes se complètent naturellement.

🧭 L'architecture en 5 étages

On va dérouler chaque étage avec du code exécutable. Objectif fil rouge : cartographier automatiquement les commerces et panneaux d'une rue à partir des photos Panoramax.

Étape 0 — Installer la stack

# Vision + accès modèles Hugging Face
pip install transformers torch pillow requests
# Géospatial (sortie GeoParquet)
pip install geopandas pyarrow shapely

Étape 1 — Interroger l'API Panoramax par emprise

L'API suit la norme STAC. On cherche les images dans une bounding box via /api/search. Chaque feature renvoyée porte sa géométrie (un point), ses assets image et ses propriétés (azimut, date).

import requests

API = "https://api.panoramax.xyz/api"  # instance centrale IGN

# bbox = lon_min, lat_min, lon_max, lat_max (ici un pâté de maisons)
bbox = [2.3500, 48.8560, 2.3540, 48.8585]

def search_pictures(bbox, limit=50):
    params = {
        "bbox": ",".join(map(str, bbox)),
        "limit": limit,
    }
    r = requests.get(f"{API}/search", params=params, timeout=30)
    r.raise_for_status()
    return r.json()["features"]

features = search_pictures(bbox)
print(f"{len(features)} photos trouvées")

# Anatomie d'une feature STAC
f = features[0]
lon, lat = f["geometry"]["coordinates"]
azimuth  = f["properties"].get("view:azimuth")   # cap de la prise de vue, en degrés
img_url  = f["assets"]["hd"]["href"]          # aussi "sd", "thumb"

💡 Insight #3 — Pensez "séquences", pas "photos isolées"
Une même devanture apparaît sur plusieurs vues consécutives d'une collection (séquence). Traiter la séquence permet de dédupliquer et de trianguler la position d'un objet vu sous deux angles — bien plus robuste qu'une détection sur une image unique.

Étape 2 — Télécharger une image

from PIL import Image
from io import BytesIO

def load_image(url):
    r = requests.get(url, timeout=60)
    r.raise_for_status()
    return Image.open(BytesIO(r.content)).convert("RGB")

img = load_image(img_url)

Étape 3 — Détection zero-shot avec un modèle Hugging Face

Le pari gagnant en 2026, c'est le zero-shot object detection : on décrit les objets en langage naturel, sans réentraîner. OWLv2 (Google) accepte une liste de requêtes texte et renvoie des boîtes englobantes. Pas de dataset annoté à constituer.

from transformers import pipeline

detector = pipeline(
    "zero-shot-object-detection",
    model="google/owlv2-base-patch16-ensemble",
)

# On décrit ce qu'on cherche, en clair
labels = ["storefront sign", "traffic sign", "shop window", "street name plate"]

detections = detector(img, candidate_labels=labels)
# → liste de dicts : {score, label, box:{xmin,ymin,xmax,ymax}}

keep = [d for d in detections if d["score"] > 0.20]
for d in keep:
    print(d["label"], round(d["score"], 2), d["box"])

💡 Insight #4 — Choisissez le bon modèle selon la tâche
Zero-shot pour découvrir sans annoter (OWLv2, Grounding DINO). Modèle fine-tuné pour la production à fort volume (plus rapide, plus précis sur un domaine étroit). Segmentation (SegFormer, Mask2Former) si vous voulez la surface et pas juste la boîte. Le pipeline ne change pas, seul le modèle change.

Étape 4 — Lire le texte des panneaux (OCR)

Une boîte « street name plate » ne sert à rien sans son contenu. On recadre la détection et on passe le crop à un modèle d'OCR. TrOCR de Microsoft est un bon défaut sur Hugging Face ; pour des plaques de rue multilignes, un VLM léger fait souvent mieux.

from transformers import pipeline

ocr = pipeline("image-to-text", model="microsoft/trocr-base-printed")

def read_box(img, box):
    crop = img.crop((box["xmin"], box["ymin"], box["xmax"], box["ymax"]))
    return ocr(crop)[0]["generated_text"]

for d in keep:
    if d["label"] in ("street name plate", "storefront sign"):
        d["text"] = read_box(img, d["box"])
        print(d["label"], "→", d["text"])

Étape 5 — Rétro-projeter la détection au sol

C'est l'étape qui sépare un POC d'un livrable. Une détection est une boîte en pixels ; il faut une coordonnée géographique. Approximation pragmatique et robuste : la position de la caméra + l'azimut de la prise de vue + le décalage horizontal de l'objet dans l'image (qui donne un angle relatif) → on projette un point à une distance estimée le long de cet azimut corrigé.

import math

def project_detection(lon, lat, azimuth_deg, box, img_w,
                       hfov_deg=70, distance_m=8):
    """Estime la position au sol d'un objet détecté.
    hfov_deg : champ horizontal de la caméra. distance_m : profondeur supposée."""
    cx = (box["xmin"] + box["xmax"]) / 2
    # angle relatif par rapport au centre de l'image (-hfov/2 .. +hfov/2)
    rel_angle = (cx / img_w - 0.5) * hfov_deg
    bearing = (azimuth_deg + rel_angle) % 360

    R = 6378137.0  # rayon terrestre (m)
    d = distance_m / R
    b = math.radians(bearing)
    lat1, lon1 = math.radians(lat), math.radians(lon)
    lat2 = math.asin(math.sin(lat1)*math.cos(d) +
                     math.cos(lat1)*math.sin(d)*math.cos(b))
    lon2 = lon1 + math.atan2(math.sin(b)*math.sin(d)*math.cos(lat1),
                            math.cos(d) - math.sin(lat1)*math.sin(lat2))
    return math.degrees(lon2), math.degrees(lat2)

💡 Insight #5 — La distance est votre plus grande incertitude
Sans profondeur (depth map ou triangulation multi-vues), distance_m est une hypothèse. Pour de la donnée fiable, triangulez le même objet sur 2+ vues de la séquence : l'intersection des deux azimuts donne une position bien plus juste qu'une distance devinée.

Étape 6 — Exporter en GeoParquet

import geopandas as gpd
from shapely.geometry import Point

rows = []
for f in features:
    lon, lat = f["geometry"]["coordinates"]
    az = f["properties"].get("view:azimuth", 0)
    img = load_image(f["assets"]["sd"]["href"])
    for d in detector(img, candidate_labels=labels):
        if d["score"] < 0.20: continue
        plon, plat = project_detection(lon, lat, az, d["box"], img.width)
        rows.append({
            "label": d["label"], "score": d["score"],
            "src_picture": f["id"], "geometry": Point(plon, plat),
        })

gdf = gpd.GeoDataFrame(rows, crs="EPSG:4326")
gdf.to_parquet("detections_rue.parquet")  # GeoParquet, lisible par DuckDB/QGIS

Vous avez maintenant une couche géo de points typés, chacun traçable jusqu'à la photo source — prête pour QGIS, DuckDB Spatial, ou une revue avant import OSM.

🧩 4 questions avant de lancer un chantier d'extraction

🏢 3 cas d'usage par secteur

🧰 La stack recommandée

📜 Les 3 règles d'or à imprimer

💬 Prompt Claude / ChatGPT prêt à l'emploi

🔗 Pour aller plus loin

• Site officiel Panoramax : panoramax.fr — présentation, instances, application mobile
• Documentation API (STAC) : docs.panoramax.fr — endpoints search / collections / items
• Logiciel libre : GeoVisio — code source du serveur Panoramax
• Modèles vision : Hugging Face Hub — huggingface.co/models (OWLv2, Grounding DINO, TrOCR, SegFormer)
• Format de sortie : spécification GeoParquet — geoparquet.org
• Cadre juridique : Google Maps Platform Terms of Service (clauses sur cache, datasets dérivés et entraînement ML)

🎁 Bonus : checklist de mise en production en 7 points

• Confirmer la couverture Panoramax de la zone (sinon planifier une captation)
• Lire et noter la licence exacte des images visées (BY-SA ou autre)
• Valider le modèle HF sur un échantillon de 50 images avant le run complet
• Mettre en place la triangulation multi-vues si la précision l'exige
• Tracer chaque détection jusqu'à sa photo source (champ src_picture)
• Vérifier la compatibilité de licence avant toute republication / import OSM
• Prévoir une étape de validation humaine systématique avant diffusion