Comment utiliser Python pour télécharger des images satellites RGB haute résolution depuis Esri World Imagery ?

Introduction

Pour demander une 'image satellite (depuis Esri World Imagery) centrée sur une latitude et une longitude données, et à un certain niveau de zoom, vous pouvez utiliser Python.

Exemple Python étape par étape

Prérequis :

1

pip install mercantile requests pillow

Code Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import mercantile
import requests
from PIL import Image
from io import BytesIO

# Définir les coordonnées centrales et le niveau de zoom
lat = 37.7749       # Exemple : San Francisco
lon = -122.4194
zoom = 12           # Niveau de zoom (0–19)

# Étape 1 : Convertir lat/lon en tuile XYZ
tile = mercantile.tile(lon, lat, zoom)
x, y, z = tile.x, tile.y, tile.z

# Étape 2 : Construire l’URL de la tuile Esri
url = f"https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"

# Étape 3 : Télécharger et afficher/enregistrer l’image de la tuile
response = requests.get(url)
if response.status_code == 200:
    img = Image.open(BytesIO(response.content))
    img.show()  # Pour l’afficher
    img.save(f"esri_tile_z{z}_x{x}_y{y}.png")  # Pour l’enregistrer
    print(f"Tuile enregistrée au zoom {z}, x={x}, y={y}")
else:
    print("Échec du téléchargement :", response.status_code)

Taille et couverture des images

Chaque image mesure :

• 256×256 pixels
• À un niveau de zoom :
  1. z=0 : le monde entier = 1 image
  2. z=1 : 2×2 images
  3. ...
  4. z=19 : résolution d’environ 38 cm, millions d'images

Remarques :

• Esri autorise l’utilisation dans le cadre de la fair use (usage raisonnable) et à des fins non commerciales. Pour un usage à grande échelle, consultez leurs conditions d’utilisation.
• Pour l’apprentissage profond (deep learning), vous pouvez normaliser lat/lon → plusieurs images → image assemblée → patch → étiquette.

Améliorer la résolution de l’image

Le serveur de tuiles Esri (https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}) fournit des images pré-rendues de 256×256 pixels, et la résolution dépend du niveau de zoom.

Si l’image semble floue ou de faible résolution, vous pouvez l’améliorer en :

1. Demandant un niveau de zoom plus élevé

Chaque augmentation du niveau de zoom double approximativement la résolution spatiale. Par exemple :

Essayez donc de définir zoom = 18 ou zoom = 19. À ces niveaux, Esri fournit souvent des images de très haute résolution (en particulier en zones urbaines).

Ligne à mettre à jour :

1

zoom = 19

Mais attention :

• L’image sera toujours seulement de 256x256 pixels, représentant une plus petite zone géographique, mais avec plus de détails.
• Pour obtenir une image plus grande avec de nombreux détails, il faut télécharger et assembler plusieurs tuiles.

2. Assembler plusieurs images (ex. : patch 3x3 ou 5x5)

Voici comment obtenir une image haute résolution centrée sur un point en assemblant plusieurs images à zoom élevé :

Installer :

1

pip install mercantile requests pillow

Code pour assembler les images :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import mercantile
import requests
from PIL import Image
from io import BytesIO

def get_tile_image(z, x, y):
    url = f"https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
    response = requests.get(url)
    if response.status_code == 200:
        return Image.open(BytesIO(response.content))
    else:
        return None

def stitch_tiles(lat, lon, zoom=18, tiles_across=3):
    center_tile = mercantile.tile(lon, lat, zoom)
    half = tiles_across // 2

    stitched = Image.new("RGB", (256 * tiles_across, 256 * tiles_across))

    for dx in range(-half, half + 1):
        for dy in range(-half, half + 1):
            x = center_tile.x + dx
            y = center_tile.y + dy
            img = get_tile_image(zoom, x, y)
            if img:
                stitched.paste(img, ((dx + half) * 256, (dy + half) * 256))
            else:
                print(f"Échec de la tuile {x},{y}")

    return stitched

# Exemple d’utilisation :
lat, lon = 37.7749, -122.4194
zoom = 18
tiles_across = 3  # pour une image de 768x768

stitched_image = stitch_tiles(lat, lon, zoom, tiles_across)
stitched_image.show()
stitched_image.save("stitched_highres_patch.png")

Résultat

• Vous obtiendrez une image de 768×768 pixels (ou plus, selon tiles_across).
• Chaque pixel aura une résolution spatiale élevée, en particulier pour zoom=18 ou zoom=19.
• Parfait pour entraîner des réseaux de neurones avec de bons détails géographiques.

Alternatives pour une meilleur résolution

Si les tuiles Esri ne sont pas suffisamment détaillées :

• Utilisez l’API Google Static Maps (usage gratuit limité)
• Essayez Maxar (commercial, via Esri Premium)
• Envisagez NAIP (1 mètre) via Microsoft Planetary Computer ou Google Earth Engine

Date d’acquisition

Lorsque vous téléchargez une tuile depuis le serveur Esri World Imagery, la date exacte d’acquisition de l’image satellite n’est pas incluse dans la tuile ni dans l’URL. Les images sont des mosaïques globales pré-rendues, et les dates varient selon la localisation et le niveau de zoom.

Vous ne pouvez pas obtenir la date d’acquisition via :`https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}'. Les métadonnées de l’image (c’est juste un PNG sans EXIF utile)

Utilisez Google Earth Engine ou Sentinel/Planet à la place

Si vous avez besoin d’un contrôle précis sur :

• La date d’acquisition
• La couverture nuageuse
• La résolution spatiale
• Les bandes spectrales

Utilisez :

• Google Earth Engine (GEE) : Interroger Landsat, Sentinel, MODIS par date
• SentinelHub ou Microsoft Planetary Computer : Accès complet aux données STAC

Résumé

Références