Le pré-découpage d'images de télédétection exige un temps de traitement considérable, un espace de stockage important et un nouveau traitement après chaque mise à jour des données. La fonction ST_AsTile de GanosBase élimine cette contrainte en générant à la demande des tuiles cartographiques standard directement à partir des données raster stockées dans PolarDB. Cette approche supprime les tâches de pré-découpage, le recours à GeoServer et la maintenance d'un cache de tuiles.
Fonctionnement
Une fois les données raster importées dans la base de données, ST_AsTile gère le recadrage, la reprojection, le rééchantillonnage et le rendu lors de l'exécution de la requête. Pour chaque coordonnée de tuile demandée (Z/X/Y), la fonction produit une tuile PNG, JPEG ou GeoTIFF de 256×256 ou 512×512 en quelques centaines de millisecondes, ce qui permet une navigation fluide sur la carte.
Les tuiles étant générées à partir des données sources en temps réel, toute modification du raster d'origine devient immédiatement visible sans qu'il soit nécessaire de relancer un traitement de découpage.
ST_AsTile traite un seul objet raster à la fois. Pour afficher plusieurs images simultanément, assemblez-les d'abord en un seul raster virtuel (voir Étape 1 : Préparer les données ).
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
-
Une instance PolarDB avec la configuration suivante :
Moteur de base de données : compatibilité syntaxique Oracle 2.0
Version du noyau : 2.0.14.25.0
Spécifications recommandées : CPU > 4 cœurs, mémoire > 16 Go, disque > 50 Go
-
GanosBase version 6.3 ou ultérieure, avec l'extension
ganos_rasterinstallée :CREATE EXTENSION ganos_raster CASCADE; Quatre images satellite Landsat 8 au format
.TIF, téléchargées dans un bucket Object Storage Service (OSS) situé dans la même région que votre instance PolarDB
Votre cluster PolarDB doit se connecter à OSS via l'endpoint interne. OSS et PolarDB doivent résider dans la même région.
Étape 1 : Préparer les données
Charger les images
Créez une table pour stocker vos données raster, puis importez chaque image depuis OSS à l'aide de ST_ImportFrom.
CREATE TABLE landsat8 (
id integer,
rast raster
);
INSERT INTO landsat8 VALUES (1, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file1.TIF'));
INSERT INTO landsat8 VALUES (2, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file2.TIF'));
INSERT INTO landsat8 VALUES (3, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file3.TIF'));
INSERT INTO landsat8 VALUES (4, ST_ImportFrom('chunk_table', 'OSS://<access_id>:<secret_key>@<endpoint>/<bucket>/path_to/file4.TIF'));
Remplacez <access_id>, <secret_key>, <endpoint> et <bucket> par vos identifiants OSS et le chemin d'accès réels. N'incluez pas les chevrons dans la chaîne de connexion finale.
Évitez d'inscrire en dur les identifiants dans les scripts SQL stockés sous contrôle de version. Dans la mesure du possible, utilisez un rôle RAM associé à l'instance PolarDB pour accorder l'accès à OSS sans intégrer de clé d'accès ni de secret.
Pour vérifier l'importation, interrogez les métadonnées du raster :
SELECT ST_Name(rast), ST_Width(rast), ST_Height(rast), ST_SRID(rast), ST_NumBands(rast)
FROM landsat8;

Assembler les images et construire les pyramides
Une fois les quatre images distinctes chargées, assemblez-les en un seul objet raster virtuel (id 101) et activez l'équilibrage des couleurs pour obtenir un rendu visuel homogène :
-- Mosaic all four images with color balancing
INSERT INTO landsat8 VALUES (101, ST_MosaicFrom(
Array(SELECT rast FROM landsat8 WHERE id < 5),
'rbt_mosaic',
'',
'{"srid":4326, "cell_size":[0.0002,0.0002], "nodata":true, "nodatavalue":0, "color_balance":true}'
));
Construisez ensuite les pyramides sur le raster assemblé. Ces pyramides constituent des vues réduites qui accélèrent le rendu aux différents niveaux de zoom :
-- Build pyramids for the mosaicked raster (id=101)
UPDATE landsat8 SET rast = ST_BuildPyramid(rast) WHERE id = 101;
Après l'équilibrage des couleurs, le raster exporté présente l'aspect suivant :

Étape 2 : Générer des tuiles avec ST_AsTile
ST_AsTile prend en entrée un objet raster et une enveloppe de tuile (définie par le niveau de zoom Z et les coordonnées X/Y), puis renvoie une tuile d'image rendue. ST_TileEnvelope convertit une adresse de tuile Z/X/Y en une boîte englobante géographique requise par ST_AsTile.
Le troisième argument de ST_AsTile correspond à un objet de configuration JSON :
| Paramètre | Description | Valeur par défaut |
|---|---|---|
format |
Format de sortie : PNG, JPEG ou GTiff. Utilisez GTiff pour conserver les valeurs brutes des pixels. |
PNG |
bands |
Indices de bandes mappés sur RVB (par exemple, "0,1,2"). |
Trois premières bandes |
strength |
Amélioration de l'affichage : none (aucun étirement), stats (étirement statistique) ou ratio (étirement basé sur un pourcentage). |
stats |
alpha |
Inclut un canal alpha pour la transparence. | — |
Exemple 1 : Image standard à 3 bandes
Pour une image RVB standard sans étirement particulier :
SELECT ST_AsTile(
rast,
ST_TileEnvelope(tile_zoom, tile_column, tile_row),
'{"strength":"none", "format":"PNG", "alpha":true}'
)
FROM landsat8 WHERE id = 101;
Exemple 2 : Image multibande avec étirement du contraste
Pour les images multibandes telles que Landsat, sélectionnez des bandes spécifiques et appliquez un étirement par pourcentage afin d'améliorer le rendu visuel :
SELECT ST_AsTile(
rast,
ST_TileEnvelope(tile_zoom, tile_column, tile_row),
'{"strength":"ratio", "format":"PNG", "bands":"0,1,2", "alpha":true}'
)
FROM landsat8 WHERE id = 101;
Dans cet exemple, les bandes 0, 1 et 2 sont mappées respectivement aux canaux R, V et B, tandis que la méthode ratio applique un étirement du contraste basé sur un pourcentage. Les valeurs tile_zoom, tile_column et tile_row correspondent directement aux paramètres de chemin {z}, {x} et {y} de l'URL HTTP de tuile servie à l'étape 3.
Étape 3 : Mettre en place un serveur de tuiles
Cette étape consiste à créer un service web Python minimaliste qui diffuse les tuiles générées par votre base de données. Ce service s'appuie sur le framework web asynchrone Quart et sur asyncpg pour garantir un accès non bloquant à la base de données.
Installer les dépendances
pip install asyncpg quart
Créer app.py
Le service expose deux routes :
/: diffuse la page HTML de la carte et calcule les limites initiales de la carte à partir de l'étendue du raster./raster/{z}/{x}/{y}: traite une requête de tuile, exécuteST_AsTilepour les coordonnées Z/X/Y spécifiées et renvoie la tuile PNG.
from quart import Quart, send_file, render_template
import asyncpg
import io
import re
# Database connection parameters
CONNECTION = {
"host": "<database-endpoint>",
"port": "<port>",
"user": "<username>",
"password": "<password>",
"database": "<database-name>"
}
TABLE_NAME = "landsat8" # Target table
RASTER_COLUMN = "rast" # Raster column name
RASTER_ID = "101" # ID of the mosaicked raster
app = Quart(__name__, template_folder='./')
@app.before_serving
async def create_db_pool():
app.db_pool = await asyncpg.create_pool(**CONNECTION)
@app.after_serving
async def close_db_pool():
await app.db_pool.close()
@app.route("/")
async def home():
sql = f'''
SELECT ST_Extent(
ST_Transform(
ST_Envelope({RASTER_COLUMN}), 4326))
FROM {TABLE_NAME}
WHERE ID = {RASTER_ID};
'''
async with app.db_pool.acquire() as connection:
box = await connection.fetchval(sql)
box = re.findall(r'BOX\((.*?) (.*?),(.*?) (.*?)\)', box)[0]
min_x, min_y, max_x, max_y = list(map(float, box))
bounds = [[min_x, min_y], [max_x, max_y]]
center = [(min_x + max_x) / 2, (min_y + max_y) / 2]
return await render_template('./index.jinja2', center=str(center), bounds=str(bounds))
@app.route("/raster/<int:z>/<int:x>/<int:y>")
async def raster(z, x, y):
# Select bands 0,1,2 as RGB with percentage-based contrast stretch
config = '{"strength":"ratio","bands":"0,1,2","alpha":true}'
sql = f'''
SELECT (
ST_AsTile({RASTER_COLUMN},
ST_Transform(
ST_TileEnvelope($1, $2, $3),
ST_Srid({RASTER_COLUMN})),
\'{config}\')
).data AS tile
FROM {TABLE_NAME}
WHERE ID = {RASTER_ID};'''
async with app.db_pool.acquire() as connection:
tile = await connection.fetchval(sql, z, x, y)
return await send_file(io.BytesIO(tile), mimetype='image/png')
if __name__ == "__main__":
app.run(port=5500) # Change the port if needed
Remplacez les valeurs de CONNECTION par l'endpoint, le port, les identifiants et le nom de la base de données de votre instance PolarDB.
Étape 4 : Créer la page cartographique
Dans le même répertoire que app.py, créez le fichier index.jinja2. Ce fichier HTML charge MapLibre GL JS et configure sa source de tuiles raster pour pointer vers l'endpoint /raster/{z}/{x}/{y} défini à l'étape 3.
Exécuter l'application
Démarrez le serveur de tuiles :
python app.py
Ouvrez http://127.0.0.1:5500 dans votre navigateur. La carte affiche vos images satellite Landsat, toutes les tuiles étant générées en temps réel depuis PolarDB.

Voir aussi
Mise en œuvre low-code de la navigation d'images de télédétection sans découpage (1) : Pyramide — alternative basée sur les pyramides pour la visualisation raster
Référence de la fonction ST_AsTile — documentation complète des paramètres
Modèle raster — principes fondamentaux du stockage et de la gestion des données raster par GanosBase
Essai gratuit de PolarDB — sélectionnez Cloud Native Database PolarDB for PostgreSQL pour tester GanosBase